Unit 1 - Practice Quiz

In a centralized system, if the central server or authority fails, the entire system can go down. This makes it a single point of failure, a problem that distributed systems aim to solve.

A hash pointer consists of two parts: a pointer to where the data is stored and a cryptographic hash of that data. This allows for the creation of verifiable, tamper-evident data structures like blockchains.

This classic problem illustrates the difficulty of having multiple parties agree on a single truth when some of those parties might be unreliable or actively trying to sabotage the process.

The double-spending problem is the risk that a digital currency can be spent more than once. Nakamoto's innovation was creating a decentralized, timestamped ledger (the blockchain) to publicly verify that a transaction has occurred, preventing the same digital coin from being used again.

A consensus algorithm is a process used to achieve agreement on a single data value among distributed processes or systems. In blockchain, it ensures every participant has an identical and valid copy of the ledger.

A Byzantine fault is the most severe type of fault, where a component can behave erratically. It could send conflicting information to different parts of the system, which is much harder to handle than a simple crash fault.

Each block contains a hash of the previous block. If an attacker alters data in a block, its hash changes. This change would cause a mismatch with the hash pointer in the next block, breaking the chain and making the tampering obvious.

Distributed ledgers allow participants to transact directly with each other in a verifiable way without needing a traditional intermediary like a bank or government to validate and record the transactions.

Byzantine Fault Tolerance is a property of a system that allows it to resist the class of failures known as Byzantine faults, where components may fail and there is imperfect information about whether a component has failed.

Scalability is a major challenge. Many robust consensus mechanisms, like Bitcoin's Proof of Work, can only process a small number of transactions per second (low throughput), which limits their use for high-volume applications.

The Genesis Block is the very first block of a blockchain, serving as the foundation upon which all subsequent blocks are built. It is the only block in the chain that does not have a preceding block.

A crash fault, or fail-stop fault, is a simple type of failure where a component stops operating entirely. This is less complex to handle than a Byzantine fault, where a component might continue to operate but in an incorrect or malicious way.

The core of the problem is that a lack of agreement leads to a catastrophic failure. If some generals attack while others retreat, they are easily defeated. This highlights the critical importance of achieving consensus.

Proof of Work is the consensus mechanism pioneered by Bitcoin. AES and SHA are cryptographic primitives (for encryption and hashing, respectively), and HTTP is a communication protocol, not a consensus algorithm.

Immutability is a key feature of blockchain, meaning that transactions recorded on the ledger are permanent and cannot be changed. This is primarily achieved through cryptographic hashing and the chain-like structure.

Satoshi Nakamoto is the name used by the presumed pseudonymous person or persons who developed Bitcoin. Their true identity has never been confirmed.

Early digital cash systems required a trusted third party (like a bank) to keep a central ledger and ensure that users did not spend the same money twice. Blockchain provided a way to solve this problem in a decentralized manner.

A block is a data structure that contains a batch of transactions, a timestamp, and a hash pointer to the previous block. Blocks are linked together to form the 'chain'.

A cryptographic hash function (like SHA-256) is a mathematical algorithm that takes an input of any size and produces a fixed-size string of characters, which is the 'hash'. This is the core component that makes the chain tamper-evident.

Consensus is the process of achieving agreement among a group of distributed participants. In blockchain, this agreement pertains to the validity and order of transactions, ensuring a single, shared truth across the network.

The core value of a distributed ledger here is not speed or initial cost, but its trust model. By distributing the record and making it cryptographically immutable, it prevents a single entity (even a corrupt administrator in the central authority) from altering historical records without detection. While authorized officials could still submit fraudulent new entries, changing past records becomes extremely difficult.

The classic solution to the Byzantine Generals Problem states that consensus can be achieved if the number of traitors () is less than one-third of the total number of generals (). The formula is . In this case, . If , then . Since , the system can tolerate up to 3 traitors. If there were 4 traitors, , and , so consensus would not be guaranteed.

Nakamoto's solution makes creating a block computationally difficult (mining). To double-spend, an attacker must create a fraudulent transaction and then build a longer chain containing it faster than the rest of the honest network. This requires immense computational power (a 51% attack). The economic incentives (block rewards and transaction fees) encourage miners to work on the valid, longest chain, making such an attack prohibitively expensive and unlikely.

A hash pointer is a data structure that contains both a pointer to the location of the previous block and the cryptographic hash of that block's data. By including the hash of Block N-1 inside Block N, it creates a chain. If any data in Block N-1 is altered, its hash will change, breaking the link from Block N and all subsequent blocks, thus making tampering immediately evident.

The Blockchain Trilemma, as proposed by Vitalik Buterin, posits that it is difficult for a blockchain to simultaneously achieve high levels of decentralization, security, and scalability. If a network is highly decentralized (many nodes must validate every transaction) and highly secure (requiring significant work or stake), its ability to process a large number of transactions per second (scalability) is typically the trade-off. For example, Bitcoin prioritizes security and decentralization, resulting in low transaction throughput.

A Sybil attack is characterized by an adversary creating a large number of pseudonymous identities to subvert a reputation system. In a blockchain context, this means creating many nodes or accounts to manipulate consensus, censor transactions, or disrupt the network. Proof-of-Work and Proof-of-Stake are mechanisms designed to mitigate Sybil attacks by making influence proportional to a scarce resource (computational power or staked capital) rather than the number of identities.

In the oral message version, a traitorous lieutenant can lie to one general about the commander's order and lie differently to another. With signed messages, the commander signs the order with their private key. A traitor can choose to not forward the message, but they cannot alter it or forge a new one, as they do not possess the commander's private key. This allows loyal generals to verify the authenticity of orders and detect forgery, making consensus easier to achieve.

In Nakamoto consensus, the 'correct' chain is the longest valid chain. It is always theoretically possible, although increasingly improbable over time, for an attacker or a network partition to create a new chain that becomes longer than the current one. This would 'orphan' the blocks on the shorter chain, effectively reversing the transactions within them. The more blocks that are built on top of a transaction (confirmations), the more computationally difficult this becomes, so the probability of reversal approaches zero, but it is never absolutely zero. This is 'probabilistic finality'.

In a consortium of competitors, trust is a major issue. If one bank controls the central ledger, it has an unfair advantage and becomes a single point of failure and control. A distributed ledger allows all participating banks to have a copy of the same data and validate transactions collectively. This removes the need to trust a single, powerful intermediary and creates a more equitable system for all participants.

Scalability isn't just about transactions per second (TPS). It's also about the ability of the network to grow and be maintained sustainably. In PoW, securing the network requires vast amounts of electricity and specialized hardware, creating a high barrier to entry. PoS lowers this barrier to the cost of the staked cryptocurrency and regular hardware. This can allow for more validators to participate, which is a component of a scalable and decentralized system, without the accompanying environmental and hardware scaling problems of PoW.

In a fail-stop model, a node's silence is an unambiguous signal that it has failed. The remaining nodes can simply proceed without it. In a Byzantine model, a malicious node is active and deceptive. It can send a 'commit' message to one node and an 'abort' message to another, actively trying to sow discord and prevent consensus. This requires complex algorithms for loyal nodes to compare messages from multiple sources to identify and ignore the malicious actor.

pBFT is designed for permissioned networks where the set of validators is known. Once a supermajority (e.g., 2/3+1) of validators agree on a block, it is considered final and cannot be reverted (deterministic finality). Nakamoto consensus, used in permissionless networks like Bitcoin, relies on the 'longest chain' rule. A block is never 100% final because a longer chain could theoretically emerge and replace it. Its finality is probabilistic and increases with each subsequent block (confirmation).

Instead of debiting and crediting accounts, the UTXO model works like digital cash. Each transaction consumes existing UTXOs as inputs and creates new UTXOs as outputs. A user's 'balance' is the sum of all UTXOs they control. This model enhances privacy (as users can use different addresses for each UTXO) and allows for easier parallel verification of transactions, as two transactions spending different UTXOs are independent of each other.

Sharding is a scalability technique that partitions the blockchain's state and transaction processing load across multiple smaller groups of nodes, called 'shards'. Instead of every node processing every single transaction (as in a monolithic blockchain like Bitcoin), each shard processes only a subset of transactions. This allows for parallel processing, significantly increasing the network's overall throughput.

The security of Nakamoto consensus rests on the assumption that honest miners control the majority of the hash rate. A 51% attack occurs when a single entity or colluding group controls more than 50% of the network's mining power. This gives them the ability to consistently mine blocks faster than the rest of the network, allowing them to rewrite parts of the blockchain, prevent transaction confirmations, and double-spend coins.

Systems like DigiCash, while innovative in their use of blind signatures for privacy, were centralized. The entire system depended on a central bank or operator to issue currency and validate transactions. This central entity could fail, be censored by a government, or act maliciously. Blockchain's key innovation was achieving decentralized control, removing the need for this trusted central party to prevent double-spending.

The BGP assumes a known, fixed number of generals. In a permissionless network like Bitcoin, nodes can join and leave freely. PoW solves this by not counting votes from identities (which are vulnerable to Sybil attacks), but by counting votes from computational power. Proposing a block requires significant work. The rest of the network accepts the version of history that has the most work invested in it (the longest chain). A Byzantine actor would need to out-work the entire honest network to impose their version of the truth.

Throughput (TPS) is fundamentally a function of how much data can be processed in a given time.

• Transactions per block = Block Size / Avg Transaction Size = 2,000,000 bytes / 500 bytes = 4000 transactions.
• Original TPS = 4000 transactions / 600 seconds ≈ 6.67 TPS.
• By decreasing the block time to 5 minutes (300 seconds), the new TPS = 4000 transactions / 300 seconds ≈ 13.33 TPS.
  This change directly doubles the rate at which blocks (and thus transactions) are processed. The other options do not directly affect the calculation of TPS.

A replicated database is typically controlled by a single administrator. All replicas trust the master copy and are just backups. If the administrator is malicious, they can alter the master copy, and this incorrect data will be replicated. A blockchain is designed for adversarial environments where participants do not trust each other. It uses a consensus algorithm to ensure all participants agree on the validity and order of transactions, creating a single, trusted version of the truth without a central coordinator.

The Bitcoin protocol includes a fixed supply of 21 million coins. The block reward, a subsidy of new coins given to the winning miner of a block, halves approximately every four years. As this subsidy decreases, the security of the network must be maintained by another incentive. Transaction fees, paid by users to have their transactions included in a block, are designed to take over this role, ensuring that miners are still economically motivated to expend computational power to validate transactions and secure the network in the long run.

In the n=3, f=1 case, imagine a loyal lieutenant (L1) receives 'attack' from the Commander (C). L1 then asks the other lieutenant (L2) what they received. If C is the traitor, they might have sent 'retreat' to L2. If L2 is the traitor, they might lie and claim they received 'retreat' from a loyal C. From L1's perspective, the world state is identical in both cases. This ambiguity makes it impossible for L1 to achieve consensus, illustrating the core reason for the n > 3f requirement.

Layer-2 solutions operate by creating channels where parties can transact privately and almost instantaneously. Only the opening and closing of these channels are broadcast to the main chain (Layer-1). This drastically improves scalability. However, it trades off the full, immediate security and decentralization of the main chain, as funds in a channel are governed by a smaller set of participants and smart contracts, introducing different, localized security assumptions.

Selfish mining involves a miner finding a block but keeping it secret, hoping to find another block to create a longer secret chain. The risk is that while they are working on their secret chain, the rest of the network finds a block for the public chain. If the public chain gets extended before the selfish miner can publish their longer chain, all their secret work is wasted (orphaned), and they forfeit the potential block rewards. This risk of wasted computational effort and lost rewards is the main economic deterrent.

The key distinction is the scope and purpose. The blockchain's linked-list structure uses hash pointers to enforce a total, immutable history between blocks over time. Changing any past block invalidates all subsequent block hashes. A Merkle tree uses the same hash pointer concept within a single block to create an efficient, verifiable summary of all transactions. It proves a transaction's inclusion and position without needing to know about any other transaction, which is crucial for SPV (Simplified Payment Verification).

This question tests the understanding of the strict requirements imposed by different fault models. BFT algorithms like PBFT require n >= 3f+1 to handle malicious actors who can lie and equivocate. Crash-fault tolerant algorithms like Paxos and Raft only need to overcome non-responsive nodes, and thus have a lower requirement of n >= 2f+1 to be able to form a majority quorum even if f nodes fail.

In PBFT, for each consensus instance, nodes must broadcast messages to all other nodes in multiple phases (prepare, commit). This results in a communication overhead that scales with the square of the number of nodes (n). As n grows, the network traffic becomes overwhelming, making PBFT impractical for large, open-permissionless networks and limiting it to smaller, permissioned consortiums.

The core innovation of distributed ledgers is not just distribution but the management of trust. In a classic client-server or primary-backup database model, there is an inherent trust in the central administrator who controls the 'master' copy and the replication process. Blockchains are designed for adversarial environments where participants do not trust each other, and consensus rules are used to agree on the state of the ledger without relying on a central coordinator.

Chaum's ecash was a centralized system. A bank (the mint) would sign a digital coin without knowing its serial number, thanks to a cryptographic primitive called a 'blind signature'. This made the coin spendable but untraceable back to the withdrawer, providing true anonymity. Bitcoin, in contrast, is decentralized. All transactions are public on the blockchain. Privacy is derived from pseudonymity—the fact that addresses are not directly linked to real-world identities, though transaction patterns can be analyzed to de-anonymize users.

A 51% attack gives the attacker control over the ordering of new transactions and the ability to create a longer chain, thus invalidating recent blocks on the honest chain. However, the attacker is still bound by the protocol's consensus rules. They cannot create invalid transactions (e.g., spending coins without the corresponding private key's signature) because such a block would be rejected by all other nodes on the network as invalid, regardless of the amount of work put into it.

With oral messages, a traitor can lie to different generals, creating the ambiguity described in the n=3, f=1 case. With digital signatures, a message is tied to its originator. If a commander sends a signed 'attack' order to L1, and L2 claims the commander sent a signed 'retreat' order, L1 can demand to see L2's signed message. If L2 cannot produce a validly signed 'retreat' order from the commander, they are exposed as a liar. This ability to prove authenticity and non-repudiation removes the core ambiguity, thus drastically reducing the number of loyal nodes required to overcome traitors. In fact, any number of traitors f can be tolerated as long as n > f.

In Nakamoto consensus (PoW), finality is probabilistic. The more blocks are built on top of a transaction's block, the exponentially more difficult (and thus less probable) it becomes to reverse it. But the probability never reaches zero. In PBFT, once a block has gone through the commit phase and has been agreed upon by 2f+1 nodes, it is deterministically final and cannot be reverted unless more than f nodes are proven to be corrupt retroactively. This makes PBFT suitable for applications like financial settlements where even a tiny chance of reversal is unacceptable.

A Sybil attack is when an adversary creates a large number of pseudonymous identities to gain a disproportionately large influence. In a naive voting system ('one IP, one vote'), this is easy. Proof-of-Work counters this by redefining what a 'vote' is. Instead of being based on a cheap-to-create identity, a vote (in the form of a valid block) is based on proof of expended computational energy. An attacker wanting 1,000 votes must perform 1,000 times the work, making the attack prohibitively expensive. It makes identity costly.

The difficulty in Bitcoin is not adjusted in real-time. It is recalculated every 2016 blocks based on the time it took to mine the previous 2016 blocks. If the hash rate doubles, the time to find a block with the current difficulty will be halved. This faster block production (approx. 5 min) will continue until 2016 blocks are mined (which will take about 1 week instead of 2). At that point, the protocol will see that the blocks were found too quickly and will adjust the difficulty upward by a factor of approximately two, restoring the 10-minute target.

While several properties are important, second pre-image resistance is the key. A block's hash is computed from its contents AND the hash of the previous block. If an attacker modifies the contents of a past block (Block N), they would need to find a new set of contents for the next block (Block N+1) that, when combined with the new hash of Block N, produces the exact same original hash for Block N+1. This is finding a second pre-image, which is computationally infeasible. This infeasibility is what makes the chain's history effectively immutable.

In a business consortium, the participants are often competitors who do not fully trust each other. If one company hosts the central database, the others must trust it not to tamper with data or deny access. A distributed ledger provides a shared, single source of truth that is not owned or controlled by any one entity. All participants validate transactions according to pre-agreed rules (smart contracts), creating a level playing field and reducing the need for costly reconciliation and trust-building exercises.

DPoS achieves high transaction throughput because consensus only needs to be reached among a small, known set of delegates (e.g., 21 in EOS). This is much faster than coordinating among thousands of anonymous nodes in PoW or PoS. The explicit trade-off is a reduction in decentralization. The network's liveness and censorship resistance become dependent on this small group of elected officials, which introduces a greater degree of centralization and potential for collusion compared to systems where anyone can theoretically produce a block.

This question tests nuanced understanding of fault models. A crash fault is simple: the node stops completely. A Byzantine fault is worst-case: the node can do anything, including lying. An omission fault lies in between. The node is alive and may respond to some requests, but it fails to send/receive certain messages. This is challenging because the node appears intermittently faulty, making it difficult for other nodes to distinguish between a node that is malicious, a node that has failed, or a network partition.

The UTXO model is a verification paradigm, not an account model. Each valid transaction must reference one or more existing, unspent outputs as its inputs. Once a UTXO is used as an input in a transaction that gets included in the blockchain, it is considered 'spent' and cannot be used again. Any subsequent transaction attempting to reference that same UTXO as an input is, by definition, invalid and will be rejected by the network. This provides a clear, stateless way for any node to verify the validity of a transaction without needing to know the entire history or balance of an 'account'.

This is a subtle but important distinction. The Byzantine Generals Problem is the core abstract problem of reaching agreement in the presence of malicious actors (traitors). A Byzantine Fault Tolerant (BFT) algorithm is a concrete protocol that solves this problem. However, a practical BFT algorithm must do more than just solve the agreement problem (safety). It must also ensure that the system continues to make progress and process new transactions (liveness), often under partially synchronous or asynchronous network conditions, which the original problem statement did not fully specify.

An SPV node downloads only block headers. It verifies the proof-of-work on the headers and uses a Merkle proof to confirm its transaction is included in a block. However, it does not download and validate all transactions in that block. Therefore, if a majority of miners collude to create a block that contains an invalid transaction (like one that violates consensus rules by creating money), they can still create a valid header and a valid Merkle proof. The SPV node would accept this block as valid, while a full node would download all transactions, discover the invalid one, and reject the entire block.