Zero-Knowledge Proof Credentials on Sui Blockchain with Walrus Decentralized Storage

A cutting-edge decentralized identity verification system that proves your credentials without revealing your personal information. Built with Groth16 ZK-SNARKs, Sui blockchain, and Walrus storage.

In today's digital world, proving your identity or credentials means sacrificing privacy:

• 🔓 Companies collect and store your personal data
• 📊 Your exact age, income, and identity are exposed
• 🎯 Data breaches put millions at risk
• 🌍 Centralized systems control your information

ZK Credential enables you to prove statements about yourself without revealing the underlying data:

✅ Prove you're over 18 → Without revealing your exact age
✅ Prove your income meets requirements → Without disclosing exact salary
✅ Prove you passed KYC → Without exposing personal details

How?

• 🔬 Zero-Knowledge Proofs (Groth16) - Cryptographic proofs that are mathematically impossible to fake
• ⛓️ Sui Blockchain - Immutable verification and credential minting
• 💾 Walrus Storage - Decentralized, permanent credential storage
• 🌐 Browser-Based - No servers, no databases, complete client-side execution

graph TB
    A[User Input] --> B[ZK Proof Generator]
    B --> C[Groth16 Circuit]
    C --> D[Proof + Public Signals]
    D --> E[WASM Serializer]
    E --> F[Arkworks Format]
    F --> G[Sui Smart Contract]
    G --> H[On-Chain Verification]
    H --> I[Credential NFT Minted]
    D --> J[Walrus Storage]
    J --> K[Permanent Blob Storage]
    I --> L[Success Screen]
    K --> L

• Node.js 20+
• A Sui Wallet (install from Sui Wallet)
• Some testnet SUI tokens (faucet)

# Clone the repository
git clone https://github.com/yourusername/zkcredential.git
cd zkcredential

# Install dependencies
npm install

# Set up environment variables
cp .env.example .env.local

# Edit .env.local with your configuration
# NEXT_PUBLIC_SUI_PACKAGE_ID=<your_deployed_package_id>
# NEXT_PUBLIC_WALRUS_ENDPOINT=https://testnet.walrus.xyz

npm run dev

Open http://localhost:3000 in your browser.

1. Click "Connect Wallet" in the top-right corner
2. Select your Sui Wallet
3. Approve the connection

Enter your credentials:

• Age: Your actual age (e.g., 25)
• Income: Your monthly income in Rupiah (e.g., 35000000)
• KYC Status: Select "Verified"

💡 Privacy Note: This data never leaves your browser!

Click "Generate Proof"

The app will:

1. ✅ Run the Circom circuit locally in your browser
2. ✅ Generate a cryptographic proof
3. ✅ Create public signals (only reveals: age ≥ 18, income ≥ 30M, KYC = true)

Time: ~3-5 seconds

Click "Upload to Walrus"

The app will:

1. ✅ Package your credential data
2. ✅ Upload to Walrus decentralized storage
3. ✅ Receive a permanent Blob ID

Result: Your data is now stored forever on Walrus!

Click "Submit to Blockchain"

The app will:

1. ✅ Serialize proof using Arkworks (WASM)
2. ✅ Send transaction to Sui smart contract
3. ✅ Verify proof on-chain using Groth16
4. ✅ Mint credential NFT

Your wallet will prompt you to approve the transaction.

Success! Your credential is now:

• ✅ Verified on Sui blockchain
• ✅ Stored permanently on Walrus
• ✅ Accessible as an NFT

On the success screen, you'll see:

Walrus Blob ID
z3UAJMCNDQPMxxxxxxxxx
[View on Walrus] 🔗

Click the button to open Walruscan:

👉 URL: https://walruscan.com/testnet/blob/YOUR_BLOB_ID

What you'll see:

• ✅ Your credential data stored as a blob
• ✅ Storage metadata (size, upload time)
• ✅ Proof that data is on Walrus testnet

On the success screen, you'll see:

Transaction Hash
0x8a3f2b1c9e4d7b5a...
[View on Sui Explorer] 🔗

Click the button to open SuiScan:

👉 URL: https://suiscan.xyz/testnet/tx/YOUR_TX_HASH

What you'll see:

• ✅ Transaction details (sender, gas used, status)
• ✅ Smart contract called: zk_credential::verify_proof
• ✅ Events emitted (proof verified, NFT minted)
• ✅ On-chain confirmation

Open browser console (F12) and look for:

✅ Proof generated successfully
✅ Public Signals: ["1", "1", "1"] // [age>=18, income>=30M, KYC=true]
✅ Walrus Blob ID: z3UAJMCNDQPMxxxxxxxxx
✅ Sui Transaction: 0x8a3f2b1c9e4d7b5a...

# Test Walrus upload
curl -X PUT https://testnet.walrus.xyz/v1/store \
  --data-binary @test.json \
  -H "Content-Type: application/octet-stream"

# Test Sui RPC
curl -X POST https://fullnode.testnet.sui.io:443 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"sui_getChainIdentifier"}'

Walrus Response:

{
  "newlyCreated": {
    "blobObject": {
      "id": "0x...",
      "blobId": "z3UAJMCNDQPM..."
    }
  }
}

Sui Response:

{
  "jsonrpc": "2.0",
  "result": "testnet-1",
  "id": 1
}

✅ File: lib/walrusStorage.ts
✅ Endpoint: https://testnet.walrus.xyz
✅ Method: PUT /v1/store
✅ Returns: Permanent Blob ID

✅ File: lib/smartContract.ts
✅ Package ID: 0x91e5baf5bb184dc7b1eeca481d2720a7ea918c5967bbffa6e6573a67d51c1ef8
✅ Contract: contracts/sources/verifier.move
✅ Function: groth16::verify_groth16_proof

// lib/zkProof.ts
const { proof, publicSignals } = await snarkjs.groth16.fullProve(
  { age: 25, income: 35000000, kycStatus: 1 },
  "/circuits/credential.wasm",
  "/circuits/credential_final.zkey"
);

Output:

• proof: Groth16 proof (3 points: A, B, C)
• publicSignals: ["1", "1", "1"] (only boolean results!)

// lib/walrusStorage.ts
const response = await fetch('https://testnet.walrus.xyz/v1/store', {
  method: 'PUT',
  body: credentialData
});

const { blobId } = await response.json();
// blobId: "z3UAJMCNDQPMxxxxxxxxx"

// vk-converter/src/lib.rs
use ark_serialize::CanonicalSerialize;

let proof_bytes = proof.serialize_compressed();
// Converts to Arkworks format for Sui Move

// contracts/sources/verifier.move
public fun verify_and_mint(
    proof: vector<u8>,
    public_inputs: vector<u8>,
    vk: vector<u8>,
    ctx: &mut TxContext
) {
    // Verify proof using groth16::verify_groth16_proof
    assert!(verified, E_INVALID_PROOF);
    
    // Mint credential NFT
    let credential = Credential { ... };
    transfer::transfer(credential, sender(ctx));
}

# Run deployment script
./deploy.sh

# Follow Railway setup instructions
# See: RAILWAY_DEPLOYMENT.md

Live Demo: [Your Railway URL]

• ✅ Zero-Knowledge: Proofs reveal nothing beyond the statement
• ✅ Client-Side: All computation happens in your browser
• ✅ No Backend: No server stores your data
• ✅ Immutable: Blockchain records can't be altered
• ✅ Decentralized: Walrus ensures data availability

• Groth16: Industry-standard ZK-SNARK
• Trusted Setup: Uses Powers of Tau ceremony
• Curve: BN254 (same as Ethereum)
• Security Level: 128-bit

zkcredential/
├── app/                    # Next.js app directory
├── components/             # React components
├── lib/                    # Core libraries
│   ├── zkProof.ts         # ZK proof generation
│   ├── walrusStorage.ts   # Walrus integration
│   ├── smartContract.ts   # Sui integration
│   └── wasmSerializer.ts  # Arkworks serialization
├── contracts/              # Sui Move contracts
│   └── sources/
│       └── verifier.move  # On-chain verifier
├── vk-converter/           # Rust WASM module
├── public/
│   ├── circuits/          # ZK circuits (.wasm, .zkey)
│   └── wasm/              # Compiled WASM modules
└── scripts/                # Deployment scripts

• Circom Documentation
• SnarkJS Guide
• ZK Learning Resources

• Sui Documentation
• Sui Move Book
• Sui Testnet Faucet

• Walrus Docs
• Walruscan Explorer

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit changes: git commit -m 'Add amazing feature'
4. Push to branch: git push origin feature/amazing-feature
5. Open a Pull Request

This project is licensed under the MIT License.

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: [email protected]

Built with:

• Sui Foundation
• Walrus Storage
• Circom Team
• Arkworks

Made with ❤️ for a privacy-first future

• Live Demo: [Your Railway URL]
• Sui Package: 0x91e5baf...c1ef8
• GitHub: github.com/yourusername/zkcredential

🚀 Ready to prove your credentials without revealing your secrets? Let's go!