60Blockchain & DLT (testing-oriented)

60.1 Blockchain vs DLT

Distributed Ledger Technology (DLT) = umbrella term: any database replicated across multiple nodes with no central authority. Blockchain = one specific type of DLT where transactions are grouped into blocks, each cryptographically linked to the previous via a hash — forming an immutable chain.

All blockchains are DLTs. Not all DLTs are blockchains (e.g. Hashgraph uses a "DAG" structure instead of blocks).

60.2 Core security mechanisms

• Cryptographic hashing (SHA-256 in Bitcoin) — each block contains a hash of the previous. Change one transaction → its block hash changes → all subsequent hashes invalid.
• Public-key cryptography — private key signs transactions; public key (derived) verifies. Possession of private key = ownership of funds.
• Consensus — how nodes agree on the next block. PoW (Bitcoin — compute hashes), PoS (Ethereum 2 — stake tokens), PBFT (Hyperledger — Byzantine fault tolerance), etc.
• Decentralisation — no single point of failure / trust.

60.3 Bitcoin — the basics

• Created by pseudonymous Satoshi Nakamoto, 2009.
• Wallets hold private keys (HD wallets derive many keys from one seed).
• Addresses are derived from public keys (hashed for compactness).
• Transactions are UTXO-based — each spend consumes prior outputs and creates new ones.
• Mining — nodes compete to solve a PoW puzzle; winner adds the next block and earns the block reward + fees.
• Block time ~10 minutes.
• Forensics — addresses are pseudonymous, not anonymous. Companies (Chainalysis) trace flows.

60.4 Ethereum & the EVM

• Smart contract platform — programs run on every node.
• EVM (Ethereum Virtual Machine) — sandboxed execution environment.
• Gas — each operation costs gas; user pays gas fee × gas price. Prevents infinite loops.
• Account model (not UTXO) — externally owned (EOA) vs contract accounts.
• Solidity — most common contract language.
• Moved to Proof-of-Stake (PoS) in 2022 (The Merge).

A tiny smart contract

// Solidity (Java-ish syntax — using java highlighter for clarity)
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private value;
    event ValueChanged(uint256 newValue);

    function set(uint256 newValue) public {
        value = newValue;
        emit ValueChanged(newValue);
    }
    function get() public view returns (uint256) {
        return value;
    }
}

60.5 Hyperledger Fabric — permissioned blockchain

• Open-source, Linux Foundation project
• Permissioned — known participants, not anonymous
• No mining — uses PBFT-style consensus
• Channels — private sub-ledgers between subsets of participants
• Chaincode — Hyperledger's term for smart contracts (Go, Java, JS)
• Use cases: supply chain, trade finance, healthcare records

60.6 Token standards

60.7 Cryptocurrencies vs tokens

• Cryptocurrency = native asset of a blockchain (BTC on Bitcoin, ETH on Ethereum). Used to pay gas / transaction fees.
• Token = asset issued by a smart contract on an existing blockchain (USDT on Ethereum). Doesn't have its own chain.

60.8 What SDETs actually test in blockchain apps

Layer 1: dApp UI (Playwright)

test('connect wallet flow', async ({ page, context }) => {
  /* Inject mock wallet — most teams use a mocked window.ethereum */
  await context.addInitScript(() => {
    (window as any).ethereum = {
      isMetaMask: true,
      request: async ({ method }: any) => {
        if (method === 'eth_requestAccounts') return ['0xAbc...123'];
        if (method === 'eth_chainId') return '0x1';
      },
      on: () => {},
    };
  });
  await page.goto('/');
  await page.getByRole('button', { name: 'Connect Wallet' }).click();
  await expect(page.getByText(/0xAbc...123/)).toBeVisible();
});

Layer 2: Smart contract (Hardhat / Foundry / Truffle)

// Hardhat test (TypeScript)
import { ethers } from 'hardhat';
import { expect } from 'chai';

describe('SimpleStorage', () => {
  it('stores and reads a value', async () => {
    const Factory = await ethers.getContractFactory('SimpleStorage');
    const contract = await Factory.deploy();
    await contract.set(42);
    expect(await contract.get()).to.equal(42);
  });

  it('emits ValueChanged event', async () => {
    const c = await (await ethers.getContractFactory('SimpleStorage')).deploy();
    await expect(c.set(7)).to.emit(c, 'ValueChanged').withArgs(7);
  });
});

Layer 3: Indexer / API

Most dApps run a backend indexer (The Graph, custom) that reads blockchain events and serves a normal REST/GraphQL API. Test that like any API — schema, status codes, latency. Just need a known on-chain state to query against.

60.9 Special challenges

• Non-deterministic timing — block confirmation takes seconds to minutes. Test on a local devnet (Hardhat / Anvil) where blocks are mined instantly.
• Gas costs — assert gas usage per transaction stays within budget (regression detector).
• Forks — fork mainnet at a specific block for realistic state.
• Reorgs — transient state can change. Wait for N confirmations before asserting.
• Security — smart contracts are immutable post-deploy. Bugs = lost funds. Pre-deploy audits (Trail of Bits, OpenZeppelin), invariant tests (Foundry / Echidna), formal verification.