Basic programming knowledge is recommended. No prior blockchain experience is required.

This course introduces students to the fundamental concepts and practical applications of blockchain technology, with a focus on Bitcoin, Ethereum, smart contracts, decentralized applications and trust-based digital systems.

The course starts from the problem of trust in distributed systems and explains how blockchain combines cryptography, distributed ledgers and consensus mechanisms to create transparent, auditable and tamper-resistant digital records. Students will first study the basic principles of blockchain and Bitcoin, then move toward Ethereum, wallets, transactions, gas, smart contracts and decentralized application architecture.

The course has a strong practical orientation and is structured in two parts. During the face-to-face week, students will create a test wallet, perform a transaction on an Ethereum test network, use Remix IDE, write and deploy Solidity smart contracts, and work in teams to design a minimal blockchain-based prototype for a real-world scenario.

During the online follow-up, students will extend the smart contract prototype toward a simple decentralized application by connecting the contract to a web frontend using ABI, contract address, MetaMask and a web3 library such as ethers.js. This second part helps students understand how a smart contract becomes part of a complete application flow, from user interface to wallet interaction and blockchain execution.

The course is designed to be interactive and application-oriented. Students will discuss when blockchain is useful, when it is not appropriate, and how it can be applied in domains such as industrial systems, product traceability, digital certificates, maintenance logs, audit trails and decentralized applications.

The course consists of 80 hours and is structured in two parts:

• Part I: 35 hours face-to-face at University Politehnica of Bucharest;
• Part II: 40 hours online follow-up.

The face-to-face part consists of interactive lectures, guided demonstrations, practical blockchain exercises and a Remix-based team prototype. Students will study blockchain foundations, Bitcoin, cryptography, Ethereum, wallets, Remix IDE, Solidity and smart contract development.

The face-to-face part ends with a team-based Remix smart contract prototype. The online follow-up continues the practical work developed during the face-to-face week through an individual frontend integration task. Each student connects a smart contract to a simple web interface and demonstrates basic decentralized application interaction using ABI, contract address, MetaMask and ethers.js.

Part I

Day 1: Blockchain Foundations and Bitcoin

Introduction to blockchain technology. Trust problems in distributed systems. Immutability, decentralization, transparency and consensus. Centralized versus decentralized architectures. Byzantine Generals Problem. Bitcoin genesis and peer-to-peer value transfer. Transactions, blocks, miners, Proof of Work and the UTXO model. Practical blockchain explorer activity.

Day 2: Cryptography, Wallets and Ethereum + first Remix contact

Hash functions, public/private keys, digital signatures and transaction integrity. Difference between signing and encryption. Wallets, seed phrases and blockchain addresses. Ethereum accounts, transactions, nonce, gas and transaction lifecycle. Introduction to smart contracts, ABI, bytecode and the Ethereum Virtual Machine. Practical activities: MetaMask wallet, Sepolia test transaction and first contact with Remix IDE through a very simple smart contract.

Day 3: Gradual Solidity lab + CertificateRegistry TODO

Gradual introduction to Solidity and Remix IDE through simple smart contract examples. Students will study contract structure, state variables, functions, visibility, constructor, msg.sender, require, modifiers, events, structs and mappings. The session progresses from simple contracts to a guided teacher demo of a certificate verification smart contract. Students then complete a TODO version of the contract and test it in Remix.

Day 4: Team Blockchain Prototype

Students work in teams to adapt the smart contract pattern studied on Day 3 to a real-world use case. Possible directions include document/certificate verification, product or asset registry, and maintenance/inspection logs. Teams define actors, on-chain data, off-chain data, access control, verification logic and demo steps. The prototype is implemented and tested in Remix.

Day 5: Face-to-face prototype demo

Teams finalize their smart contracts, prepare a short presentation and demonstrate their prototype in Remix. Each team explains the problem, the blockchain relevance, the smart contract design, the data model, the verification logic, the limitations and possible future improvements.

Practical Activities

The practical part includes:

• blockchain explorer analysis;
• MetaMask wallet creation;
• Sepolia test transaction;
• Remix IDE introduction;
• Solidity smart contract development;
• guided TODO smart contract exercise;
• team-based prototype implementation;
• face-to-face Remix demo and presentation.

 

Face-to-Face Prototype Assessment

The face-to-face part ends with a team project presentation and Remix-based prototype demonstration. Each team must submit:

• a short presentation;
• one Solidity smart contract;
• a Remix demo scenario;
• a short explanation of the blockchain use case, actors, on-chain/off-chain data and limitations.

 

Part II

Online Follow-up: From Smart Contract Prototype to Simple DApp

The online part consists of 40 hours and continues the practical work developed during the face-to-face week. Students will learn how a smart contract can be connected to a frontend and how users interact with blockchain applications through a wallet.

The online follow-up is organized into five modules of approximately 8 hours each.

 

 

Online Module 1: From Smart Contract Prototype to DApp Architecture

Students review the Remix-based smart contract prototype and study the architecture of a decentralized application. The module introduces the relationship between frontend, wallet, provider, smart contract and blockchain. Students learn the role of the ABI and contract address and understand the difference between read-only calls and state-changing transactions.

Practical activity: students prepare the structure of a simple frontend and identify the ABI and contract address required for interaction with their smart contract.

Online Module 2: Frontend Connection with MetaMask and ethers.js

This module introduces wallet connection from a web interface. Students learn how MetaMask exposes a blockchain provider, how to request user accounts, how to check the connected network and how to create a contract instance using ethers.js.

Practical activity: students implement a simple Connect Wallet button, display the connected address and call read-only smart contract functions from the frontend.

Online Module 3: Sending Transactions from the Frontend

Students learn how a frontend sends transactions to a smart contract. The module explains the role of the signer, MetaMask confirmation, transaction hash, transaction receipt, gas and basic error handling.

Practical activity: students implement frontend forms for calling state-changing functions such as issuing a document, registering a product or registering an inspection record. They also implement revoke, deactivate or invalidate operations depending on their chosen project.

Online Module 4: Events, Logs and User Interface Feedback

This module explains how smart contract events are used by decentralized applications for audit trails and user interface feedback. Students study the difference between contract storage and transaction logs and discuss what data should be stored on-chain and what data should remain off-chain.

Practical activity: students improve their frontend by displaying transaction results, emitted events or updated verification status after a transaction is confirmed.

Online Module 5: Final DApp Integration and Presentation

Students finalize their mini-DApp, test the interaction between frontend, wallet and smart contract, and prepare the final presentation. The final demo must show a complete user flow: wallet connection, smart contract interaction, state-changing transaction, verification/read function and explanation of emitted events or results.

Practical activity: final project integration, debugging, presentation preparation and final online demo.

The final assessment has two components:

1. Team-based face-to-face prototype
   During the face-to-face week, students work in teams to design and implement a Remix-based smart contract prototype for a real-world blockchain use case.
2. Individual online frontend integration
   During the online follow-up, each student individually extends the smart contract idea toward a simple decentralized application interface. The individual work must show how a frontend connects to a smart contract using ABI, contract address, MetaMask and ethers.js.

For the individual online component, each student must submit:

·       one simple frontend connected to a smart contract, implemented for example in CodePen, plain HTML/CSS/JavaScript or another simple web environment approved by the teacher;

·       a demo scenario showing wallet connection and smart contract interaction;

·       at least one read-only call from the frontend;

·       at least one state-changing transaction from the frontend;

·       a short individual presentation explaining the application purpose, the smart contract functions used, the frontend interaction flow, the role of MetaMask, the on-chain/off-chain data and the limitations of the solution.

The team prototype developed during the face-to-face week may be used as the starting point, but the online frontend integration and final explanation must be completed individually.