[Discussions on Twitter, LinkedIn, and Comments under the post]

[Updated:

  • Source code of Smart contract here.

]

Today, I’m writing about “Using blockchain in retrieval system student accomplishments”

During their studying of student, the student has accomplishments and needs a highly reliable system to verify them. Blockchain technology with data transparency is the solution for this system.

Student accomplishments include?

In this topic, I define accomplishments include: Kudo card and Certificate.

Kudo card

This is a card and on this include: name of the sender, name of receiver and important part of the card is compliments. We can use this to praise our friends or thank our lecturer for help. Kudo card can create by all people. Kudo card has spiritual value and based on this we can have comprehensive reviews about the individual contributions of students in learning.

kudo_card
Kudo card example

Certificate

Maybe the certificate is close to everyone. A certificate is an official document that states that the information on it is true (Cambridge dictionary). The certificate was issued when you achieve achievements in competition, participate in an extracurricular activity, etc. Unlike kudo card, the certificate was created by an organization and has legal value.

kudo_card
Certificate example (This is the certificate of my ICPC team, you can read about my team here and here, sorry for the inconvenience because it is only in Vietnamese, but I think you can use the translation tool if you want to read ^^)

How to store?

First, the certificate and kudo card can exist in a PDF file. For convenience, we only store the hash of the PDF file.

Where to store PDF files?

To ensure decentralized nature, we will store the file in the decentralized distributed file system. In this topic, I propose to use IPFS (InterPlanetary File System). The InterPlanetary File System (IPFS) is a peer-to-peer distributed file system that seeks to connect all computing devices with the same system of files. In some ways, IPFS is similar to the Web, but IPFS could be seen as a single BitTorrent swarm, exchanging objects within one Git repository. In other words, IPFS provides a high throughput content-addressed block storage model, with content-addressed hyper links. This forms a generalized Merkle DAG, a data structure upon which one can build versioned file systems, blockchains, and even a Permanent Web. IPFS combines a distributed hashtable, an incentivized block exchange, and a self-certifying namespace. IPFS has no single point of failure, and nodes do not need to trust each other (Read more about IPFS here).

In IPFS, for flexibility, we encode the file by base58 to binary string and store it in IPFS. In retrieval, we get the encoding string and decode it into a file.

What to store on the blockchain?

On the blockchain, we only store the hash of the file for validation. In this, I use the One-Way hash function SHA-256, I choose SHA-256 because we do not need to save the original file, I will analyze it later. Using SHA-256, we can optimize storage capacity and it helps save cost for transactions on the blockchain.

Smart contract (SC)

We consider a certificate or kudo card is an NFT. To make sure a certificate or kudo card is unique, I use the method of adding a QR code of the timestamp created it, you can see an example again. In general:

H(F) = H(I + T)

where:

  - H: Hash function
  - F: PDF file
  - I: Information includes: creator, receiver, achievement, etc.
  - T: Timestamp

Sometimes, information possible to duplicate, in this case, the timestamp will make sure two PDF files is different or it is unique.

I use two smart contracts to manage, one for certificate and one for kudo card on the blockchain. SC using the standard token ERC-721 to implement.

Smart contract for Kudo card (Kudo)

SC of Kudo includes information:

Kudo{
  tokenID: ID of token
  uri: link to pdf file stored on IPFS
  hashOfPDF: sha-256 hash of PDF file
  addressCreateToken: address of the creator
  addressOfOwnerToken: address of the owner
  timestampOfToken: timestamp when token created
  statusOfID: status of token is Valid or Invalid, default is Valid.
}

Pseudocode for basic functions in Kudo:

Mint function

FUNCTION mint(address_from, address_to, uri, hashFile):
  IF checkValid(hashFile) == False:
    RETURN "Invalid hash"
  IF checkExistHash(hashFile) == True:
    RETURN "Hash already exists"
  IF address_from == address_to:
    RETURN "You can not mint tokens for self"

  setUriForToken(uri)
  setOwnerForToken(address_to)
  setCreatorForToken(address_from)
  setTimestampForToken(time_data_wirte_on_block)

In this function, we have some notes:

  • First, we must check the format of the hash is valid or not (is the SHA-256 hash or not). Because if someone intentionally put a long string, it will make SC crash because it takes much time for processing requests.
  • Check whether a hash exists or not because an NFT is unique and the hash is the representation of the file therefore the hash of the file must be unique. This is why we just store the hash of the file that I mentioned here. Also, storing only the SHA-256 hash of the file helps protect private information.
  • Check address mint and address receiving must be different because self-praise is meaningless.
  • If the above conditions are valid, data will store on the blockchain.

Disable token function

FUNCTION disableToken(address, id):
  IF checkExistHash(hashFile) == False:
    RETURN "Invalid ID"
  IF addressCreateToken[id] != address OR addressOfOwnerToken[id] != address:
    RETURN "You not permission to delete it"
  IF current_timestamp – timestampOfToken[id] > 1 day:
    RETURN "You cannot delete kudo card created more than 1 day"

  setStatusOfID(id) = "Invalid"

I write this function because in some cases, we can miscommunicate on the kudo card, and with this function, we can mark a token as invalid. Note that, it doesn’t delete data on the blockchain, it only marks a token as invalid, this action didn’t violate the decentralized nature of the blockchain.

Since anyone can create the kudo card, to prevent bad behavior from affecting recognition, only those who create the token or the owner of the token can delete and processing can be done if the token is created not more than 1 day.

Validate function

FUNCTION validate(hashFile, id):
  IF checkExistHash(hashFile) == False OR statusOfID[id] == "Invalid":
    RETURN "Invalid"
  ELSE:
    RETURN "Valid"

On the blockchain, we have the hash of the PDF file and hence we need to check whether the hash input exists on the blockchain or not and check the status of the token is valid or not. If all is valid, this is a valid file or vice versa.

Smart contract for Certificate (Cert)

Almost similar to Kudo, since the certificate was issued by organizations we must add some information about permission in SC.

Cert{
  tokenID: ID of token
  uri: link to pdf file stored on IPFS
  hashOfPDF: sha-256 hash of PDF file
  addressCreateToken: address of the creator
  addressOfOwnerToken: address of the owner
  timestampOfToken: timestamp when token created
  statusOfID: status of token is Valid or Invalid, default is Valid.
  roleOfAddress: role of address.
}

Compared to Kudo, Cert addition role of address. It has two types of roles:

  • Admin: Admin has the permit to set or revoke permission to create the certificate for address. Admin address is the address deployed SC on the blockchain.
  • Cert_role: The address has this permission can create the certificate. Only the address that has this permission can create a certificate, even the admin role can not create it.

Pseudocode for basic functions in Cert:

Grant CERTROLE function

FUNCTION grantCertRole(address_perform, address_grant):
  IF roleOf(address_perform) != "ADMIN":
    RETURN "You must be admin"
  IF roleOf(address_grant) == "ADMIN":
    RETURN "You are admin"
  IF roleOf(address_grant) == "CERTROLE":
    RETURN "Address has been CERTROLE"

  grantRoleFor(address_grant) = "CERTROLE"

First, the function check address call function is Admin or not. The authorized address has not been previously issued a CERTROLE and not an Admin address.

Revoke CERTROLE function

FUNCTION revokeCertRole(address_perform, address_revoke):
  IF roleOf(address_perform) != “ADMIN”:
    RETURN “You must be admin”
  IF roleOf(address_revoke) != “CERTROLE”:
    RETURN "Address has not CERTROLE”

  revokeRoleFor(address_revoke)

Similar to the grant function, it will check and if it is valid, it will revoke the address.

Mint function

FUNCTION mint(address_from, address_to, uri, hashFile):
  IF roleOf(address_from) != “CERTROLE”:
    RETURN "Address has not CERTROLE”
  IF checkValid(hashFile) == False:
    RETURN "Invalid hash"
  IF checkExistHash(hashFile) == True:
    RETURN "Hash already exists"
  IF address_from == address_to:
    RETURN "You can not mint tokens for self"

  setUriForToken(uri)
  setOwnerForToken(address_to)
  setCreatorForToken(address_from)
  setTimestampForToken(time_data_wirte_on_block)

In the mint function, the address call action (address_from) will be checked has CERTROLE or not. All actions after that are the same as the function of Kudo.

Disable token function

FUNCTION disableToken(address, id):
  IF checkExistHash(hashFile) == False:
    RETURN "Invalid ID"
  IF addressCreateToken[id] != address OR addressOfOwnerToken[id] != address:
    RETURN "You not permission to delete it"

  setStatusOfID(id) = "Invalid"

Since the certificate was managed by organizations, a certificate can revoke at any time.

Validate function

FUNCTION validate(hashFile, id):
  IF checkExistHash(hashFile) == False OR statusOfID[id] == "Invalid":
    RETURN "Invalid"
  ELSE:
    RETURN "Valid"

Smart contract source code

Source code of SC here.

Use in practice

perform
System use in practice

Demo

Smart contract deploys on blockchain Polygon testnet. Details of smart contract here.

Acknowledgment

  • I would like to sincerely thank Dr. Hai Tran for helping me step by step complete this topic, this is also my Graduate thesis.

  • I would like to thank my friend Thao Pham for her suggestions on this topic.

Thanks for reading and look forward to receiving your comments and discussions!



Photo credit:

  • https://www.wallpaperflare.com/grad-cap-diploma-and-stacked-books-photo-school-young-adult-wallpaper-aawmn