INFO6001: Blockchain Technology and Applications Assignment 2

Rationale

The purpose of this assessment is to test your ability to:

• Entity registration ( Citizen , Sensor ) with uniqueness checks and events. Data submission ( submitReading ) storing timestamped readings and emitting events. Access control via simple modifiers ( onlyAdmin , onlyRegisteredSensor ). Token reward logic (basic ERC20-style reward) to incentivize validated submissions. Clear comments and separation into logical files for readability.

• Design blockchain models that address specific business needs.

• Prototype blockchain applications for smart city or smart environment scenarios.

• Apply knowledge of distributed ledger systems to solve real-world problems.

This assessment simulates real-world tasks where blockchain solutions must address complex requirements in dynamic environments. It aims to equip students with critical problem-solving and design skills.

Task Description

Students are required to design and implement a set of Solidity smart contracts using Remix.
These contracts will simulate core blockchain features applicable to Smart City or Smart Environment applications.

Although the specific domain will be introduced later (in Assessment 3), the contracts must be:

• Modular

• General-purpose

• Adaptable for different scenarios

Task Instructions

Step 1: Understand the Business Requirement

Students should study general business scenarios where blockchain can provide value.
Examples include:

• Smart City Applications:

  • Blockchain for energy trading

  • Blockchain for traffic data sharing

  • Blockchain for smart parking systems

• Smart Environment Applications:

  • Blockchain for waste management

  • Blockchain for environmental monitoring

  • Blockchain for carbon credit systems

Task: Choose one scenario, analyse it, and identify the role of blockchain in solving the business problem.

Step 2: Prototype the Blockchain

Students must design smart contracts in Solidity with the following functionality:

1. Entity Creation

• Allow users to register or initialize as entities.

• Example entities: citizens, sensor devices, service points.

• Use a struct with basic data (e.g., name, address, ID).

• Store entity records using a mapping.

2. Use of require() and Modifiers

• Apply basic logic checks to manage access or usage of functions.

• Examples:

  • Prevent duplicate registrations

  • Prevent unauthorized submissions

3. Data Submission or Interaction

• Entities should be able to submit data or interact with the system.

• Examples:

  • Citizens submitting a report

  • Sensors submitting readings

  • Incrementing counters or recording transactions

4. Token or Credit Logic (Optional)

• Use ERC20 or ERC721 token standards as learned in class.

• Possible applications:

  • Reward citizens for submitting valid data

  • Represent carbon credits or traffic tokens

  • Track ownership of digital assets representing real-world items

Note: Students are encouraged to add additional features that enhance the chosen scenario.

5. Code Quality

• Ensure the code is modular.

• Add thorough comments for readability and maintainability.

Step 3: Test the Prototype

Students must demonstrate functionality through test scenarios:

• Provide sample inputs and outputs to validate:

  • Block addition

  • Transaction validation

  • User interaction

• Example:

  • Registering a new citizen

  • Submitting an environmental reading

  • Awarding tokens for valid submissions

Submission Requirements

• A working set of Solidity smart contracts in Remix

• Documented test cases with input/output examples

• Clear explanation of how the prototype meets the business requirements

Brief summary of assessment requirements (key pointers)

Goal: Design and implement modular Solidity smart contracts (in Remix) that simulate core blockchain features for a Smart City or Smart Environment scenario.
Core expectations (short):

• Choose one scenario (e.g., energy trading, waste management, environmental monitoring) and explain why blockchain adds value.

• Entity creation: structs + mappings for citizens, sensors, service points, etc.

• Validation & access checks: use and modifiers to prevent duplicates/unauthorized actions.

• Data submission / interactions: allow entities to submit reports/readings/events; record on-chain state and emit events.

• Token/credit logic (optional): implement ERC20/ ERC721-style logic to reward/represent assets.

• Modularity & comments: separate contracts / libraries / interfaces and thorough inline comments.

• Testing: demonstrate with concrete test scenarios (inputs/outputs) that validate registration, submissions, token rewards, and transaction handling.

• Submission: working Solidity files in Remix, documented test cases, and an explanation tying the prototype back to business requirements.

How the Academic mentor guided the student — step-by-step process

Below is a concise walkthrough of the mentor’s approach and the student actions for each section.

1) Framing the business problem & selecting the scenario

Mentor guidance: Discuss several candidate scenarios (e.g., smart parking vs environmental monitoring). Ask the student to pick one and list the main actors, assets, and pain points.
Student action: Chose environmental monitoring (example). Identified actors: admin , sensor devices , citizens/reporters , regulator/market .
Why: This clarifies scope and the blockchain role (immutability, decentralized data sharing, audit trail, tokenized incentives).

2) High-level design & data model

Mentor guidance: Sketch entity models and interactions before coding. Define what data is stored on-chain vs off-chain. Use simple structs and mappings.
Student action: Designed struct Citizen, struct Sensor , struct Reading and mapping(address => Citizen) / mapping(uint => Sensor); planned events for major actions.
Why: Keeps contracts focused and gas-efficient; ensures each entity has a unique key.

3) Implement entity creation with validation

Mentor guidance: Show patterns for safe registration: uniqueness checks, require messages, and modifiers to limit who can call sensitive functions.
Student action: Implemented registerCitizen() and registerSensor() with a requirement to block duplicates, and onlyAdmin modifier for admin-only ops. Emitted CitizenRegistered and SensorRegistered events.
Why: Demonstrates function-level checks and prevents inconsistent state.

4) Data submission & interaction patterns

Mentor guidance: Teach how to accept readings/reports (simple example: submitReading(sensorId, readingData) ), store minimal on-chain metadata, and emit events for off-chain processing. Discuss throttling/nonce checks if needed.
Student action: Built submitReading() to store Reading objects (timestamped), increment counters, and emit ReadingSubmitted events. Added a require to restrict sensors to their own IDs.
Why: Shows practical data flow and how ledger records provide traceability.

5) Optional token/credit integration

Mentor guidance: Walk through ERC20 basics and a minimal reward flow — mint or transfer tokens when a reading is validated. Explain tradeoffs (gas, complexity).
Student action: Implemented a lightweight ERC20-like contract or integrated an ERC20 mock; created called after validation. Tokens track incentives (e.g., carbon credits or participation rewards).
Why: Demonstrates linking application logic to token economics.

6) Modularity, comments & code hygiene

Mentor guidance: Encourage separation: Entities.sol , ReadingManager.sol , TokenReward.sol. Add NatSpec-like comments for public functions.
Student action: Split contracts, used interfaces where needed, added comments and clear variable names.
Why: Improves readability, reuse, and grading clarity.

7) Test scenarios in Remix

Mentor guidance: Prepare concrete test cases (happy path + edge cases) and run them in Remix with sample addresses and values. Record inputs/expected outputs.
Student action: Ran tests: register entities, submit readings, attempt duplicate registration (expect revert), award tokens, check balances, and reviewed events/logs. Documented each test case.
Why: Verifies correctness and shows understanding of transaction flow and error handling.

8) Documentation & submission packaging

Mentor guidance: Ask for a brief README that explains architecture, how to run tests, and which learning objectives are met.
Student action: Compiled final README, uploaded Solidity files, and included sample inputs/outputs and a short mapping of features to business requirements.

Outcome — How the assessment goals were achieved (concise)

What was implemented

• Entity registration ( Citizen , Sensor ) with uniqueness checks and events.
  Data submission ( submitReading ) storing timestamped readings and emitting events.
  Access control via simple modifiers ( onlyAdmin , onlyRegisteredSensor ).
  Token reward logic (basic ERC20-style reward) to incentivize validated submissions.
  Clear comments and separation into logical files for readability.

Example sample test cases (inputs → expected outputs)

• registerCitizen(name, addr, id) → event CitizenRegistered , mapping updated.

  Duplicate registerCitizen with same addr → require revert (prevents duplicate).

  registerSensor(sensorId, owner) → SensorRegistered event.

  submitReading(sensorId, "PM2.5: 45") → ReadingSubmitted event, reading stored, readingCount++ .

  validateReading(readingId) by admin → emits ReadingValidated and calls rewardCitizen() transferring tokens.

• Check balances → citizen token balance increased by reward amount.

How these meet assessment requirements

• Business alignment: System supports environmental monitoring with immutable records and audit trail. Token rewards encourage participation and data quality.

• Technical coverage: Demonstrates structs/mappings, require /modifiers, events, optional token logic, modular code, and tests.

• Deliverables: Solidity code (Remix-ready), documented test cases, and a short design explanation linking features to business needs.

Learning objectives covered (mapped to original goals)

• Design blockchain models that address business needs: Scenario mapping, actor/asset modeling, on-chain vs off-chain decisions.

• Prototype blockchain applications for smart city/environment: Working smart contracts for registration, data capture, and incentives.

• Apply distributed ledger knowledge to real problems: Immutability, event logs for off-chain processing, tokenization for incentives.

• Additional practical skills: Access control patterns, safe input validation, modular contract design, event-driven architecture, and Remix-based testing.

Quick deliverables checklist (for submission)

• files (modular contracts)

• README (architecture, how to run tests)

• Documented test cases with sample input/output and expected behavior

• Short reflection mapping prototype to chosen business scenario and learning objectives

Get Expert Help with Your Assignment

Looking for guidance on how to structure and present your assessment? Our sample solution is available to give you a clear idea of formatting, content flow, and key academic requirements. Use it as a reference only to strengthen your own understanding.

Important: Submitting this sample directly as your own work may lead to plagiarism issues. Universities have strict academic integrity policies, so the file is meant purely for study support and reference purposes.

If you need a 100% original, plagiarism-free, and custom-written solution tailored to your specific requirements, our team of professional academic writers is here to help. With expertise across multiple subjects, we ensure:

• Freshly written, unique content for your topic

• Proper formatting, citations, and academic style

• On-time delivery, even with tight deadlines

• Reliable support throughout your academic journey

Take the stress out of assignments and get expert support when you need it most.

Your two options:

• Download Sample Solution – Learn how to structure your work.

• Order Fresh Assignment – Get a custom, plagiarism-free solution written just for you.