Blockchain Fundamentals

Initialize a Node.js project and explain the purpose of package.json.

Import and export code using Node.js modules.

Parse and serialize JSON data in a Node.js program.

Use promises and async/await to handle asynchronous operations.

Call a public HTTP API and handle successful and failed responses.

Use environment variables to keep configuration values outside source code.

Create commits and branches in Git for a small coding project.

Distinguish centralized databases, distributed ledgers, and blockchains by their trust assumptions.

Compute a hash with a standard library and verify how input changes affect its output.

Explain how public and private keys support ownership without exposing a private key.

Sign a message with a development library and verify its signature.

Describe how Merkle trees enable efficient inclusion proofs.

Trace how transactions, blocks, nodes, and consensus interact in a blockchain.

Compare full nodes, light clients, wallets, and block explorers by function and trust requirements.

Explain Bitcoin's goals and design trade-offs in relation to trusted payment intermediaries.

Interpret addresses, transaction IDs, block heights, confirmations, inputs, and outputs in a Bitcoin explorer.

Trace ownership changes through a simple chain of Bitcoin UTXOs.

Select UTXOs and calculate transaction change for a specified payment.

Estimate a Bitcoin transaction fee from virtual size and a given fee rate.

Explain how digital signatures and locking conditions authorize Bitcoin spending.

Decode the major fields of a raw Bitcoin transaction using developer tooling.

Describe how Bitcoin nodes validate and relay transactions and blocks.

Explain proof of work, mining difficulty, and cumulative chain work.

Differentiate consensus rules, mining incentives, and network governance.

Read a simple Bitcoin Script locking-and-unlocking sequence.

Compare legacy, SegWit, and Taproot transaction formats at a functional level.

Query Bitcoin test-network data from a Node.js script through a public API.

Explain how payment channels and the Lightning Network trade on-chain settlement for faster payments.

Compare Bitcoin's UTXO model with Ethereum's account-based state model.

Differentiate externally owned accounts from contract accounts.

Interpret value, calldata, nonce, gas limit, fee fields, and receipt status in an Ethereum transaction.

Calculate the maximum transaction cost from a stated gas limit and fee parameters.

Trace a contract call through transaction execution, state change, and event logging.

Explain how EVM bytecode, opcodes, memory, storage, and the stack relate during execution.

Connect to an Ethereum test network with a wallet while applying safe key-handling practices.

Create and compile a minimal Solidity contract using a browser-based development environment.

Declare Solidity value types, reference types, state variables, constants, and immutable values.

Write functions with parameters, return values, visibility, and state-mutability modifiers.

Use require, revert, and custom errors to enforce contract conditions.

Apply if statements and bounded loops in Solidity functions.

Use arrays, mappings, and structs to model contract data.

Explain how storage, memory, and calldata affect reference-type variables.

Implement role-based state changes using msg.sender and access checks.

Emit an event and retrieve its indexed and non-indexed data from a transaction log.

Define and implement a Solidity interface for cross-contract interaction.

Use inheritance and function overriding in a small contract hierarchy.

Apply a constructor to initialize contract state and dependencies.

Implement receive and fallback behavior for Ether transfers and unmatched calls.

Compare push and pull patterns for transferring Ether from a contract.

Set up a local Solidity development project with a standard testing framework.

Write a unit test for a successful contract state transition.

Write a unit test that expects a contract call to revert.

Use fixtures or setup hooks to isolate contract tests.

Measure test coverage and identify an untested contract branch.

Deploy a contract to a local development network with a deployment script.

Deploy a tested contract to an Ethereum test network and verify its address and interface.

Create a JavaScript provider connection to an EVM development or test network.

Read public contract state from JavaScript using an ABI and contract address.

Request wallet account access without handling the user's private key.

Submit a state-changing contract transaction from JavaScript.

Wait for a transaction receipt and present success or failure to the user.

Subscribe to or query contract events from JavaScript.

Display wallet, network, balance, and contract-state information in a minimal web interface.

Identify an access-control flaw in a short Solidity contract.

Demonstrate the checks-effects-interactions pattern against a simple reentrancy risk.

Explain when arithmetic checks and precision loss can affect contract behavior.

Identify unsafe uses of tx.origin, delegatecall, and external calls.

Detect front-running or transaction-ordering risk in a simple contract workflow.

Apply pause and withdrawal controls to limit the impact of a contract incident.

Run a static-analysis tool and triage its findings against contract behavior.

Write a regression test for a corrected smart-contract vulnerability.

Select a small EVM application problem and define its users, trust assumptions, and on-chain requirements.

Specify the contract state, functions, access rules, events, and failure conditions for the application.

Implement one core contract workflow from the specification.

Create tests for the workflow's successful, unauthorized, and invalid-input cases.

Connect a minimal JavaScript client to the tested contract workflow.

Document local setup, contract usage, security limitations, and test-network deployment.

Compare Bitcoin application, EVM development, protocol engineering, and smart-contract security roles by daily tasks and prerequisite skills.

Evaluate the capstone against a checklist and create a twelve-week follow-on specialization plan.