Certificates

Unlear Network’s certificates bring together the best properties of physical and digital objects.

An Unlearn Network Certificate is somewhat similar to a skill or level achieved in a game.

  1. A certificate is part of one or more skill trees. Getting a certificate may open up other branches to explore.
  2. It may have pre-requisites:
    • one or more other certificates
    • one or more exams
    • a specific type of credit
    • a specific amount of credit
    • payment
    • or any combination of the above
  3. It has protection against obsolete knowledge, so it can expire:
    • by time
    • by events
    • it can be extended / updated / maintained
  4. It is a collectible.
  5. It is endorsed by certain entities or individuals
  6. It may offer benefits – “drop” discounts or other valuable objects

Permanent Digital Objects

Unlearn Network’s certificates are trustless, independent objects. It means that these digital objects don’t depend on Unlearn Network’s servers or services. They will keep existing even when Unlearn Network or the issuer institution ceases to exist.

Secure

The Digital Objects can’t be faked. Creating counterfeits is not possible. Nobody can create a counterfeit certificate in the name of an institution, or change the details in it. This solves the problem with the widespread fake educational certificates.

Relevant Knowledge

Unlearn Network’s certificates have built-in protection against obsolete knowledge. Unlike traditional certificates, these digital objects

They were designed to prove that the knowledge they certificate is existing, active knowledge.

In the short writeup below we describe some of its properties and design principles.

Issuer

The Issuer is the issuing institution (or individual). It is commonly an educational institue or company, For example PSB Academy or the Etereum Foundation. It is usually the same entity who develops or comissions the course material.

Endorser(s)

The Issuer should almost always be the Endorser as well. But there could me more endorsers. Endorser could be a domain expert who have reviewed the course and the exam, and endorsed it to give an extra importance to the certificate. For example Zooko Wilcox might decide to endorse a zCash course developed by the zCash foundation.

Student

The Student is the one who takes the course, the exam and receives the certificate. Like all other parties, the student is also identified by their address.

Course

The course is an educational unit, that has educational material, examples, and tests. The educational content is outside of the scope of this project. It can be on a website or stored in an educational cms, like edx.

Validity

The validity of a certificate is one of its most important property.

By default, all certificates have an expiration date, since no knowledge in the relative universe is absolute and lasts forever. Also, a certificate has a limited self-time in terms of usefulness as well. A certificate of JavaScript proficiency might not be relevant to a person who has settled in Okinawa, producing tofu.

But expiration date is not the only way how certificates can lose their validity. They might get invalidated by research or new discoveries in their respective fields. For example a blockchain security expert certificate may get invalidated by a new form of attack that was just discovered. Once the required addition to the course was added, the already issued certificates might get temporarily invalidated by the Issuer. The Student can restore the good state of their certificate by taking the required addendum.

Certificates can also be invalidated by other factors – for example if a Student is caught cheating. We will go deeper into these later. For now, it is important to know that certificates can be invalidated by several factors, including time and the Issuer.

Eligibility and Pre-requisites

A ceritifcate may have pre-requisites. The pre-requiseites can be

  • other, specific certificates (aka dependencies)
  • a certain amount and certain type of cedit
  • awards or other artifacts, represented by NFT tokens

A certificate is only valid if all dependencies are satisfied.


Technical Details

This solidity contract allows minting of certificates by pre-approved users (keys)

e.g.

ethereum foundation = 0x4DD771Dc7903C1ed483218e319725A1dF1e7b8bE
linux foundation = 0xaB6189F15aD8855F26D60A413734212E7181A23A

Certificate Data

each pre-approved user may issue certificates with the following data

    struct CertificateDetails {
        bytes  student_copy;
        bytes  issuer_copy;
        uint256 course_id;
        string  serialNumber;
        uint256 expiry;
        bool   invalidated;
    }

This data is intended as follows

student_copy

The student copy has been encrypted with the student’s RSA public key

issuer_copy

The issuer copy has been encrypted with the issuer’s RSA public key

SerialNumber

This should be a unique serial number

CourseID

Each course should have a unique course ID

Expiry

The date the certificate ceases to be valid

Invalidated

This is set if a certificate has been revoked

Accessing Certificate Data

The certificates may be accessed by student (key / index), issuer (key / index) or overall Certificates (index)

These functions allow you to access a certificate by its position

function numberOfCertificates() public view  returns (uint256)
function certificateByIndex(uint256 index) public view  returns (uint256)

These functions allow you to access a certificate by its owner and position

function numberOfCertificatesOwnedBy(address owner) public view  returns (uint256)
function certificateOfOwnerByIndex(address owner, uint256 index) public view returns (uint256)

These functions access information by course

    function numberOfCourses() public view returns (uint256)
    function numberOfAttendees(uint256 courseID) public view returns (uint256) 
    function certificateForCourse(uint256 courseID, uint256 index) public view returns (uint256)

These functions, given the certificate ID, return the certificate’s details

function getCertificateExpiry(uint256 certificateID) external view returns (bool valid, uint256 expiryDate)

NOTE: These functions will revert if the certificate has been invalidated or has expired

function getStudentCopy(uint256 certificateID) external view returns (bytes memory studentVersion)
function getIssuerCopy(uint256 certificateID) external view returns (bytes memory issuerVersion)
function getSerialNumber(uint256 certificateID) external view returns (string memory serialNumber)
function getCourseID(uint256 certificateID) external view returns (uint256 courseID)

function ownerOf(uint256 certificateID) public view  returns (address)
function issuerOf(uint256 certificateID) public view  returns (address)

getting a new courseID

Note : coursenames are not stored in the contract for the sake of privacy

    function newCourseID(string courseName) public onlyIssuer returns (uint256)

issuing certificates

    function createCertificate(
        address recipient,
        string calldata serialNumber,
        bytes calldata studentCopy,
        bytes calldata issuerCopy,
        uint256 courseID,
        uint256 expiryDate) external onlyIssuer

Any issuer may issue a certificate

invalidating (revoking) certificates

    function invalidateCertificate(uint256 certificateID) public onlyIssuer

A certificate may only be revoked by the key that issued it.

issuer management

only the contract’s owner can add and remove issuers.

    function addIssuer(address issuer) external onlyOwner
    function removeIssuer(address issuer) external onlyOwner

The current implementation of the certificate already implements many of the above, but not all. The code will be audited and then released under the MIT license.