Functions, Constructors and require

Solidity functionsSearch on YouTubeBookmarkSaved

A function in Solidity is a self-contained, executable block of code. It decides how a contract behaves, calculates data, or changes the blockchain's permanent state.

Every function follows a strict formula:

function <name>(<parameters>) <visibility> <state modifier> returns (<return type>) { <body> }

Types by visibilitySearch on YouTubeBookmarkSaved

Visibility modifiers are internal firewalls. They define exactly who may trigger a function.

public (universal access)Search on YouTubeBookmarkSaved

string public latestStudent;

// An open door: anyone can trigger this function to update the state.
function issueCertificate(string memory _studentName) public {
    latestStudent = _studentName;
}

Anyone can call it: external wallets, other contracts and other functions in the same contract.

private (maximum restriction)Search on YouTubeBookmarkSaved

// Only other functions in THIS file can trigger the hash generation.
function _generateInternalData(string memory _studentName) private pure
returns (bytes32) {
    return keccak256(abi.encodePacked(_studentName, "UNIVERSITY_SECRET"));
}

Only functions inside this exact contract can call it. It is invisible to the outside world and to any contract that inherits from it. Convention: prefix private function names with an underscore.

internal (inheritance allowed)Search on YouTubeBookmarkSaved

bool public systemActive = true;

// Hidden from the public, but can be used by an inheriting "MedicalCollege" contract.
function _validateCertificate() internal view returns (bool) {
    // Reverts the transaction if the system is not active
    require(systemActive == true, "System is currently paused");
    return true;
}

Like private, it is invisible to the outside world. But a new contract that inherits this one can use it.

external (outside access only)Search on YouTubeBookmarkSaved

// Designed exclusively for employers or web portals querying the contract.
// Internal contract logic cannot trigger this check.
function verifyCertificate(uint256 _certificateId) external view returns (bool) {
    // Logic to verify and return the certificate status
    return true;
}

Only outside users or other contracts can call it. A function inside the contract cannot call its own external function directly.

Types by state interactionSearch on YouTubeBookmarkSaved

The EVM strictly tracks how a function touches permanent storage.

Analogy: a university degreeSearch on YouTubeBookmarkSaved

Constructors: giving the contract an identitySearch on YouTubeBookmarkSaved

The problem with version 1Search on YouTubeBookmarkSaved

function issueCertificate(string memory _studentName) public { ... }

If anyone can call issueCertificate(), anyone can create a certificate. Anyone is the university. An attacker can submit a transaction that overwrites any degree with fake data. Smart contracts are open by default. This contract has no concept of identity and no memory of who created it.

The fix: teach the contract to remember the real university identity at deployment. Three tools: the address type, msg.sender, and the constructor.

The address data typeSearch on YouTubeBookmarkSaved

Every Ethereum account (wallet) and contract is identified by a unique 20-byte (160-bit) value, written as 40 hex characters prefixed with 0x. Solidity has a primitive type for it: address.

// Stores the blockchain identity of IIIT Kottayam
address public university;

Use address whenever the contract needs to know who something is. Who owns the contract? Who may issue certificates? Which student receives a degree? Where should payment go? The goal: the contract remembers who called a function, so later it can ask who is calling now.

msg.senderSearch on YouTubeBookmarkSaved

Blockchains have no logins. A contract knows its caller through msg.sender.

• msg.sender is a built-in global variable.
• It evaluates to the address of the account (or contract) that started the current function call.
• Its value is set at run time for every transaction or call.

function getCaller()
    public
    view
    returns (address)
{
    return msg.sender;
}

Call it from Account 1 and then Account 2 in Remix. Each call returns the address of the account selected at that moment.

Why not a setter?Search on YouTubeBookmarkSaved

function setUniversity(address _university) public {
    university = _university;
}

This creates another problem: who can call setUniversity()? Anyone, so the attacker sets themselves as the university.

The constructorSearch on YouTubeBookmarkSaved

A constructor is an optional special function that runs exactly once, when the contract is deployed, and never again. It is not added to the runtime bytecode. After the deployment transaction finishes, it can never be called.

// Runs ONCE during deployment
constructor() {
    university = msg.sender;
}

When this contract is deployed, take the address of whoever deployed it (msg.sender) and save it permanently in university.

UniversityDegree v2Search on YouTubeBookmarkSaved

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract UniversityDegree {

    // Address of the university
    address public university;

    uint256 public certificateId;
    string public studentName;
    uint256 public registerNumber;
    string public degree;
    string public department;
    uint256 public graduationYear;
    bool public isValid;

    // Runs once when the contract is deployed
    constructor() {
        university = msg.sender;
    }

    // Issue certificate (still public: anyone can call it)
    function issueCertificate(
        uint256 _certificateId,
        string memory _studentName,
        uint256 _registerNumber,
        string memory _degree,
        string memory _department,
        uint256 _graduationYear
    ) public {
        certificateId = _certificateId;
        studentName = _studentName;
        registerNumber = _registerNumber;
        degree = _degree;
        department = _department;
        graduationYear = _graduationYear;
        isValid = true;
    }
}

In Remix: deploy from Account 1 (0x5B38Da6a701c568545dCfcB03FcB875f56beddC4). The university getter returns that address. Switch to Account 2 and call it again: it still returns Account 1. The value is fixed in storage, independent of the current caller.

Now the contract knows the university's address. But the door to issueCertificate() is still wide open; it is still public.

require(): access controlSearch on YouTubeBookmarkSaved

Only the university should issue a certificate. We already know two things: who is the university (university) and who is calling now (msg.sender). We need logic that compares them.

require() is a built-in check that takes a condition and an error message:

require(condition, "error message");

• If the condition is true, execution continues to the next line.
• If it is false, execution stops at once and the whole transaction is reverted. Every change made so far in that call is undone, as if it never happened. The error message is returned to the caller.

require() validates things before acting:

• Is the caller authorised?
• Is the input valid? (for example, the student name is not empty)
• Does this record already exist? (prevent a duplicate certificate)
• Is the contract in the right state for this action?

UniversityDegree v3Search on YouTubeBookmarkSaved

function issueCertificate(
    uint256 _certificateId,
    string memory _studentName,
    uint256 _registerNumber,
    string memory _degree,
    string memory _department,
    uint256 _graduationYear
) public {
    require(
        msg.sender == university,
        "Only university can issue"
    );

    certificateId = _certificateId;
    studentName = _studentName;
    registerNumber = _registerNumber;
    degree = _degree;
    department = _department;
    graduationYear = _graduationYear;
    isValid = true;
}

function getCertificate() public view returns (
    uint256, string memory, uint256, string memory, string memory, uint256, bool
) {
    return (certificateId, studentName, registerNumber, degree, department, graduationYear, isValid);
}

// Return the address stored as the university
function getUniversity() public view returns (address) {
    return university;
}

// Return the address of the current caller
function getCaller() public view returns (address) {
    return msg.sender;
}

Test in Remix:

1. From Account 1 (the deployer), call issueCertificate(1111, "Jai Ganesh", 1234, "B. Tech", "Cyber", 2026). It succeeds. getCertificate returns 1111, Jai Ganesh, 1234, B. Tech, Cyber, 2026, true.
2. From Account 2, call issueCertificate(2222, "SpiderMan", 1122, ...). It fails: "The transaction has been reverted to the initial state. Reason provided by the contract: Only university can issue."

Order mattersSearch on YouTubeBookmarkSaved

// Wrong: checks after writing
function issueCertificate(...) public {
    certificateId = _certificateId;
    studentName = _studentName;
    require(msg.sender == university, "Only university can issue");
}

// Right: check first, then write
function issueCertificate(...) public {
    require(msg.sender == university, "Only university can issue");
    certificateId = _certificateId;
    studentName = _studentName;
}

The deck's demo code is at https://jaiganesh.notion.site/Solidity-Programs-3f0cb97603228087a92af9ed52f5a091 (short link https://shorturl.at/tjWQ3).

Quick self-testSearch on YouTubeBookmarkSaved