🎓 Build Your Own Certification System using Soulbound Tokens

An interactive blockchain development challenge for students

Start Challenge · View Demo · Report Bug · Request Feature

Certify

🌟 Achievement Tracks

🏆 Beginner Track (0-400 points)

📚 Learn Blockchain Basics  [50 points]
🔧 Setup Development Environment [50 points]
🚀 Deploy First Smart Contract [100 points]
💎 Create Your First SBT [100 points]
🔍 Execute Basic Queries [100 points]

🎯 Intermediate Track (400-700 points)

🔄 Implement Advanced Contract Functions [100 points]
🎨 Build Basic Frontend [100 points]
🔌 Integrate Contract with Frontend [100 points]

👑 Advanced Track (700-1000 points)

🎮 Create Interactive UI [100 points]
📊 Implement Analytics Dashboard [100 points]
🌐 Deploy Full Production DApp [100 points]

🎯 Challenge Overview

Welcome to the Certify DApp Challenge! This hands-on tutorial will guide you through building a complete blockchain-based certification system. By the end, you'll have created a fully functional DApp that issues and manages Soulbound Tokens (SBTs) on the Kalp blockchain.

What You'll Build

graph LR
    A[Smart Contract] --> B[SBT Token]
    B --> C[Frontend]
    C --> D[User Interface]
    D --> E[Certification System]

Learning Outcomes

🔷 Master Soulbound Token implementation
🔷 Develop production-grade smart contracts
🔷 Build modern web frontends with Next.js
🔷 Integrate blockchain with web applications
🔷 Deploy full-stack DApps

🚀 Getting Started

Prerequisites

Tool	Version	Download
Go	>=1.19, <1.20	Download
Node.js	>=14.x	Download
npm	>=6.x	Included with Node.js
Postman	Latest	Download
Kalp Studio Account	-	Sign Up

📦 Quick Start

Clone Repository

git clone https://github.com/thekalpstudio/Certify.git
cd certify

Setup Smart Contract
```
cd sbtkalp
go mod tidy
```

Configure Frontend

cd ../certification
npm install
cp .env.example .env.local

💎 Challenge Modules

Module 1: Smart Contract Development [300 points]

🎯 Learning Objectives

Understand Soulbound Token (SBT) implementation
Master Kalp SDK functionalities
Learn blockchain state management
Implement secure smart contract patterns

📋 Prerequisites [25 points]

Install Go (>=1.19, <1.20)
Set up GOPATH and workspace
Basic understanding of blockchain concepts
Familiarity with Go programming

🚀 Setup Environment [25 points]

Create project directory:
```
mkdir sbtkalp
cd sbtkalp
```
Initialize Go module:
```
go mod init sbtkalp
```

Install Kalp SDK:

go get -u github.com/p2eengineering/kalp-sdk-public/kalp

Initialize vendor directory:
```
go mod vendor
```

💎 Core Contract Components [100 points]

1. Data Structures [25 points]

// SBT Metadata structure
type NFTMetadata struct {
    Description  string `json:"description"`
    Name         string `json:"name,omitempty"`
    Organization string `json:"organization,omitempty"`
    DateOfIssue  string `json:"dateOfIssue,omitempty"`
}

// Main SBT structure
type SoulboundToken struct {
    Owner    string `json:"owner"`
    TokenID  string `json:"tokenID"`
    Metadata string `json:"metadata"`
}

// Smart Contract structure
type SmartContract struct {
    kalpsdk.Contract
}

2. State Management [25 points]

// State prefixes for organization
const sbtPrefix = "soulboundToken"
const ownerMappingPrefix = "sbtOwnerMapping"

// Composite key creation example
compositeKey, err := sdk.CreateCompositeKey(sbtPrefix, []string{owner, tokenID})

3. Core Functions [50 points]

a. Initialize Contract [15 points]

Challenge Task: Implement the initialization function with the following requirements:

Check if contract is already initialized
Store metadata in JSON format
Set contract state
Handle errors appropriately

b. MintSBT Function [20 points]

Challenge Task: Implement token minting with these features:

Generate unique TokenID using UUID
Validate owner status
Store token data
Create composite keys

c. QuerySBT Function [15 points]

Challenge Task: Implement query functionality that:

Retrieves token details
Validates existence
Returns formatted data

🎮 Implementation Challenges [150 points]

Challenge 1: Implement Token Management [50 points]

Contract State Initialization

func (s *SmartContract) Initialize(sdk kalpsdk.TransactionContextInterface, description string) error {
    // Your initialization code here
    // Hint: Use the provided metadata structure
}

Tasks:

Check contract status
Create metadata
Store initialization flag
Handle errors

Token Creation System

func (s *SmartContract) MintSBT(sdk kalpsdk.TransactionContextInterface, address string) error {
    // Your minting code here
    // Hint: Use UUID for token generation
}

Tasks:

Generate token ID
Validate address
Create token record
Update state

Challenge 2: Query System [50 points]

Implement these query functions:

Basic Token Query

func (s *SmartContract) QuerySBT(sdk kalpsdk.TransactionContextInterface, owner string, tokenID string) (*SoulboundToken, error)

Owner-Based Query

func (s *SmartContract) GetTokenMetadata(sdk kalpsdk.TransactionContextInterface, owner string) (*SoulboundToken, error)

Token Listing

func (s *SmartContract) GetAllTokenIDs(sdk kalpsdk.TransactionContextInterface) ([]string, error)

Challenge 3: Advanced Features [50 points]

Transfer Prevention System

func (s *SmartContract) TransferSBT(sdk kalpsdk.TransactionContextInterface, from string, to string, tokenID string) error {
    // Implement transfer prevention
    // Hint: This should always return an error
}

Composite Key Management

// Example composite key creation
mappingKey, err := sdk.CreateCompositeKey(ownerMappingPrefix, []string{address})

📝 Code Quality Guidelines [25 points]

Code Organization
- Clean file structure
- Consistent naming
- Clear documentation
Error Handling
- Descriptive messages
- Proper propagation
- Recovery handling
Documentation
- Function comments
- Usage examples
- State management explanation

🏆 Success Criteria

To complete Module 1:

✅ Implement all core functions
✅ Pass provided test cases
✅ Follow code guidelines
✅ Document your code
✅ Handle errors properly

📚 Resources

Development Tools:
Documentation:

🎯 Next Steps

After completion:

Review your implementation
Document your learnings
Prepare for Module 2
Share your achievements

Good luck with the challenge! 🚀

Module 2: Frontend Integration [300 points]

// Example: Mint New Token [100 points]
const mintSBT = async (recipientAddress: string) => {
  try {
    await fetch('https://gateway-api.kalp.studio/v1/contract/kalp/invoke/[CONTRACT_ID]/MintSBT', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': process.env.NEXT_PUBLIC_API_KEY!,
      },
      body: JSON.stringify({
        network: "TESTNET",
        blockchain: "KALP",
        walletAddress: "[YOUR_WALLET]",
        args: {
          address: recipientAddress
        }
      })
    });
  } catch (error) {
    console.error('Error minting SBT:', error);
  }
};

Module 3: Deployment & Testing [400 points]

Smart Contract Deployment [150 points]
- Follow Deployment Guide
- Configure Kalp Wallet
Frontend Deployment [150 points]
```
npm run build
npm run dev
```
Integration Testing [100 points]
- Complete API Testing Guide
- Implement comprehensive test suite

Example:🔒 Interact with Smart Contract Using Postman

Prerequisites:

After executing the above setup:

After deploying the smart contract in Kalp Studio, an API endpoint will be generated. This API endpoint can be used to interact with the deployed smart contract.

Here is an example of a generated API endpoint route in Kalp Studio:

Click on Check Params, and the routing details and parameters should look like this:

An API key is required for authorization in API POST requests.

It looks like this in Kalp Studio:

Setting Headers in Postman:

Set the required headers for authentication:

Key: x-api
Value: Paste the auth key you obtained after API key generation in Kalp Studio.

🌐 Required Resources

Smart Contract Links

API Configuration

Contract ID: vHYQcRijQGB3UpVhqc3UeBM2D3ztjPuS1732534432325
Default Wallet: ded665bca7d412891f44a571d908b66184b0ee10
API Documentation

🏆 Achievement Unlocking

Beginner Achievements

🎯 Environment Wizard
🎯 Contract Master
🎯 Token Creator

Intermediate Achievements

🎯 Frontend Pioneer
🎯 Integration Specialist
🎯 Testing Guru

Advanced Achievements

🎯 DApp Architect
🎯 Production Master
🎯 Full Stack Developer

🆘 Support & Community

📜 Certification Process

Complete all challenge modules
Submit your project for review
Pass the technical assessment
Receive your SBT certification
Join the Kalp Developer Community

🎮 Best Practices

✅ Follow Go programming conventions
✅ Write comprehensive tests
✅ Document your code
✅ Use proper error handling
✅ Implement security best practices

🔜 Next Steps

After completing this challenge:

Explore advanced Kalp features
Contribute to open source projects
Join the developer community
Build your own DApps

Happy Coding! 🚀

Get Started | Join Community | View Documentation

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
certification		certification
sbtkalp		sbtkalp
.DS_Store		.DS_Store
.gitattributes		.gitattributes
LICENSE		LICENSE
README.md		README.md

License

PrabalParihar/Certify

Folders and files

Latest commit

History

Repository files navigation