Student ID NFT: ERC721 for Campus Access, Mess, and Library

The current state of college IDs is a plastic card printed at the start of every semester, distributed in long queues at the bursar office, and reissued whenever a student loses it (which happens roughly once per student per year at most campuses). The replacement chain — fees clearance, card production, distribution — takes days.

An NFT student ID lives in the student's wallet on their phone. Losing the phone does not lose the ID; the student logs into a backup wallet and the same token is there. Reissuance is unnecessary. Semester renewal is one function call on the contract — no new cards printed, no queues, no laminated photos.

Same ERC721 base contract as a starting point — the work is in the per facility access map and the fees gate.

// Student ID NFT — soulbound, semester scoped
contract StudentId is ERC721, AccessControl {
    bytes32 public constant ADMISSIONS_ROLE = keccak256("ADMISSIONS_ROLE");
    bytes32 public constant SCANNER_ROLE = keccak256("SCANNER_ROLE");

    struct Student {
        string rollNumber;
        string department;     // "CS", "EE", "BBA"
        uint16 batchYear;
        uint64 validUntil;     // end of current semester
        bool feesPaid;         // gate for campus access
    }

    mapping(uint256 => Student) public student;
    mapping(uint256 => mapping(string => bool)) public access; // tokenId => facility => allowed

    event Issued(uint256 indexed id, address indexed wallet, string rollNumber);
    event AccessGranted(uint256 indexed id, string facility, address by);
    event AccessRevoked(uint256 indexed id, string facility, address by);
    event ChargeBilled(uint256 indexed id, string facility, uint256 rupees);

    constructor() ERC721("Student ID", "SID") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function issue(
        address wallet,
        string calldata rollNumber,
        string calldata department,
        uint16 batchYear,
        uint64 validUntil
    ) external onlyRole(ADMISSIONS_ROLE) returns (uint256 id) {
        id = uint256(keccak256(bytes(rollNumber)));
        student[id] = Student(rollNumber, department, batchYear, validUntil, true);
        _safeMint(wallet, id);
        emit Issued(id, wallet, rollNumber);
    }
}

The Student struct stores everything a campus scanner needs to authorize entry at a glance: roll number for display, department for analytics, batch year for graduation timing, validUntil for the semester gate, feesPaid for the bursar gate. The access map handles per facility permissions independently.

Two roles split the trust. ADMISSIONS_ROLE wallets sit inside the admissions office and can issue new IDs, update student data, set fees status, and grant facility access. SCANNER_ROLE wallets sit inside the canteen and dorm POS systems and can only charge a meal or log an entry. Compromising a scanner cannot inflate a student record; compromising admissions can.

// Campus scanner taps the wallet — door opens if all gates pass
function canEnter(uint256 id, string calldata facility)
    public
    view
    returns (bool)
{
    if (_ownerOf(id) == address(0)) return false;
    Student memory s = student[id];
    if (s.validUntil < block.timestamp) return false;
    if (!s.feesPaid) return false;
    return access[id][facility];
}

// Library, mess, gym, parking — admin grants per facility
function grantAccess(uint256 id, string calldata facility)
    external
    onlyRole(ADMISSIONS_ROLE)
{
    access[id][facility] = true;
    emit AccessGranted(id, facility, msg.sender);
}

// Fees overdue — admissions flips one bit, every door closes
function setFeesPaid(uint256 id, bool paid)
    external
    onlyRole(ADMISSIONS_ROLE)
{
    student[id].feesPaid = paid;
}

canEnter folds three conditions into a single return. Owner check confirms the wallet actually holds a valid ID. Expiry check enforces semester scoping — a student who has not re registered cannot enter. feesPaid check is the bursar gate. The per facility flag is the final layer.

The composition matters. A student in good standing for the semester whose fees are clear but who has not been granted gym access still fails canEnter at the gym door — but passes at the library door. Each facility cares about its own flag, not the others.

// Mess swipe — bill the canteen running tab
mapping(uint256 => uint256) public messBalance; // tokenId => rupees owed

function topUp(uint256 id) external payable {
    require(_ownerOf(id) != address(0), "ID: unknown");
    require(msg.value > 0, "ID: zero top up");
    // In a stablecoin model this would transferFrom USDC instead
    // Keeping payable here for narrative simplicity
    messBalance[id] += msg.value;
}

function chargeMeal(uint256 id, uint256 rupees)
    external
    onlyRole(SCANNER_ROLE)
{
    require(canEnter(id, "mess"), "ID: mess access denied");
    require(messBalance[id] >= rupees, "ID: top up first");
    messBalance[id] -= rupees;
    emit ChargeBilled(id, "mess", rupees);
}

A student tops up their meal balance through a single payable call (or a stablecoin transferFrom in a production setting). The canteen POS at lunch time scans the student wallet, reads canEnter(id, "mess"), confirms access, and calls chargeMeal with the rupee amount. The balance drops, the student gets the meal, the transaction lands in the block within seconds.

At semester start, admissions calls a setValidUntil function for each enrolled student, bumping the expiry to the end of the new semester. Students who registered for the semester are active; students who did not are automatically excluded by their expiry timestamp. The bursar runs a separate setFeesPaid pass after fee receipts clear.

Mid semester, almost nothing happens on the admissions side. Daily scanner activity does all the work — entries logged, meals charged, library checks. The admissions office only touches the contract when a student transfers departments, takes a leave of absence, or graduates.

At graduation, the student ID expiry runs out and the access flags become irrelevant. The NFT stays in the student's wallet as a historical record. The university may then issue a separate degree NFT to the same wallet — the two contracts coexist cleanly because the student wallet holds both tokens.

Existing turnstile and POS hardware does not speak EVM RPC. The integration pattern is a small middleware service per scanner that exposes a local API the hardware can call, and the middleware translates to a contract read. A Raspberry Pi at each gate is enough — under thirty dollars in hardware per door.

The admissions dashboard is a thin internal web app. The most used screens are batch issuance at semester start, fees status updates, and per facility access toggles. The whole dashboard is a few hundred lines of code over the contract's ABI.

Deploy on a layer 2 to keep gas under control. A semester start with 5,000 students issuing roughly $50 of gas total. Daily campus activity — meals, entries, library — is under one cent per event. Even at full scale, the chain costs are negligible compared to plastic card replacement.

We help universities, schools, and corporate campuses ship on chain identity and access systems, including the contract, the admissions dashboard, the scanner middleware, and the integration with existing student information systems. The pattern transfers to corporate badges, conference passes, and any environment where a single identifier needs to unlock many different facilities under one rule set.