Spark Program | CellMint, No-Code Token Creation & Management Platform for Nervos CKB

DAOs & Funding Spark Program
,
1

1. Project Overview

  • Project Name: CellMint

  • One-Sentence Summary: A no-code token launchpad that lets anyone create, deploy, and manage xUDT fungible tokens on Nervos CKB through an intuitive wizard interface zero programming required.

  • Project Type: DApp (Web Application)

    2. Team Profile

    • Core Member:

      • devokindah — Full-Stack Developer & Project Lead

    • Background:

      • Building fullstack applications

    • Contact Information:

      Problem: Creating tokens on Nervos CKB currently requires deep knowledge of the cell model, xUDT type scripts, transaction skeleton construction, and CCC SDK APIs. Even experienced developers face a steep learning curve let alone community organizers, hackathon teams, and non-technical founders who simply want to launch a token for their project.

      Scenario: Imagine a hackathon team at a CKB event. They’ve built a great DApp but need a utility token for in-app governance. Currently they must:

      1. Read through the xUDT specification and understand type script args encoding

      2. Set up a TypeScript project with CCC SDK

      3. Construct a transaction with correct inputs, outputs

      4. Handle wallet signing, fee estimation, and broadcast

      5. Debug cell capacity issues and transaction failures

      This 2–4 hour process discourages experimentation and slows ecosystem growth.

      Ecosystem Relevance: The CKB ecosystem has strong infrastructure (CCC SDK, JoyID wallets, Fiber Network) but lacks an accessible token creation interface. EVM ecosystems have tools like Coin Launch, Remix, and TokenMint, CKB has nothing equivalent. CellMint fills this gap.

4. Solution

Core Solution: CellMint provides a 3-step wizard UI that abstracts all CKB-specific complexity:

  1. Identity Step, Name, symbol, logo upload, description, social links

  2. Economics Step, Total supply, decimals (with presets), owner address (auto-fill from wallet)

  3. Review & Deploy, Preview token card, checklist, one-click deploy with animated progress

Under the hood, CellMint uses the CCC SDK (@ckb-ccc/connector-react) to:

  • Connect to JoyID, OKX, MetaMask, and other wallets via CCC’s unified interface

  • Construct xUDT type scripts from the creator’s Lock Script hash

  • Build and sign deployment transactions with automatic input selection and fee handling

  • Query deployed tokens, balances, and transaction status via CKB RPC

User Perspective: A user visits the site → connects their wallet → fills in token details → clicks Deploy → sees an animated 5-phase progress indicator → receives a success screen with tx hash and explorer link. The entire process takes under 2 minutes.

Differentiation:

Existing Approach CellMint
Write TypeScript with CCC SDK No-code wizard UI
Understand cell model & xUDT spec Abstracted behind form fields
Manual transaction construction Automatic input/output/fee handling
Single wallet support Multi-wallet via CCC connector
No token management post-deploy Dashboard with token list, detail view, management

5. Technical Approach

Tech Stack:

  • Frontend: Next.js 16 (App Router), React 19, TypeScript 5, Tailwind CSS v4

  • State: Zustand (persisted), React Hook Form + Zod validation

  • Animation: Framer Motion

  • UI Primitives: Radix UI (dialog, dropdown, tabs, accordion, select, switch, toast)

  • Blockchain SDK: @ckb-ccc/core, @ckb-ccc/connector-react

  • Networks: CKB Testnet (testnet.ckbapp.dev) / Mainnet (mainnet.ckbapp.dev)

Architecture Overview:

┌─────────────────────────────────────────────────┐
│                   Browser                        │
│  ┌───────────┐  ┌──────────┐  ┌──────────────┐  │
│  │ Landing   │  │Dashboard │  │  Wizard      │  │
│  │ Page      │  │ Shell    │  │ (3 Steps)    │  │
│  └───────────┘  └──────────┘  └──────┬───────┘  │
│                                       │          │
│  ┌────────────────────────────────────▼───────┐  │
│  │          CCC Connector React               │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │  │
│  │  │ Provider │  │ useSigner│  │ useCcc   │  │  │
│  │  └──────────┘  └──────────┘  └──────────┘  │  │
│  └──────────────────────┬─────────────────────┘  │
│                         │                        │
└─────────────────────────┼────────────────────────┘
                          │ JSON-RPC
┌─────────────────────────▼────────────────────────┐
│              CKB Node (Testnet/Mainnet)           │
│  ┌──────────┐  ┌──────────┐  ┌──────────────┐   │
│  │ xUDT     │  │ Cell     │  │ Transaction  │   │
│  │ Script   │  │ Indexer  │  │ Pool         │   │
│  └──────────┘  └──────────┘  └──────────────┘   │
└──────────────────────────────────────────────────┘

Key Technical Challenges:

  1. Transaction Construction: xUDT token creation requires precise encoding — 16-byte LE u128 for amounts, correct type script args (lock hash + "00000000"), and proper cell_deps. Solution: Wrap CCC SDK methods into a clean service layer that handles all encoding automatically.

  2. Wallet Interoperability: Different wallets have different connection protocols. Solution: CCC connector-react provides a unified signer abstraction — we use ccc.useSigner() and it works across JoyID, OKX, MetaMask etc.

  3. Token Metadata Storage: xUDT cells don’t store name/symbol/decimals on-chain — only the amount. Solution: Store metadata in localStorage (persisted via Zustand) for MVP. Future: use UniqueType cells or on-chain metadata extensions.

  4. Fee Estimation & Capacity Management: Users need CKB for cell capacity. Solution: CCC’s completeInputsByCapacity() and completeFeeBy() handle this automatically. Display CKB balance and estimated fees in the UI.

6. To-Do List

Week 1: CCC SDK Integration

  • Install @ckb-ccc/core and @ckb-ccc/connector-react

  • Replace mock wallet connection with CCC provider + signer

  • Implement real wallet connect/disconnect flow

  • Test with JoyID on CKB Testnet

Week 2: Token Deployment (Core Flow)

  • Implement xUDT token deployment using CCC SDK

  • Transaction construction: type script, outputs, outputsData, cell_deps

  • Handle input selection, fee estimation, and signing

  • Animated deployment progress with real tx hash polling

Week 3: Token Management & Dashboard

  • Query deployed tokens via cell indexer

  • Token detail page with balance, holders, tx history

  • Transfer tokens between addresses

  • Mint additional tokens (if owner)

Week 4: Polish, Testing & Documentation

  • End-to-end testing on Testnet with real wallets

  • Error handling: insufficient balance, failed tx, network issues

  • UI polish: loading states, error toasts, responsive design

  • Documentation: README, setup guide, architecture doc

  • MVP Live Demo, full token creation and management flow.

7. Required Funding & Funding Breakdown

A. Required Funding: $900

B. Funding Breakdown:

Week Category Amount Purpose
1 Technical $250 CCC SDK integration, wallet connection, project scaffolding
2 Technical $250 xUDT deployment logic, transaction construction, signing flow
3 Technical $200 Token management, dashboard, transfer/mint features
4 Technical and Community $200 Testing, documentation, demo preparation
Total $900

Justification: This is a single-category technical project focused on frontend DApp development with CCC SDK integration. The $900 budget covers 4 weeks of focused development, testing infrastructure, and documentation. The scope is well-defined,a web-based token creation wizard, with a clear tech stack and established SDK, keeping costs manageable.

8. Deliverables and How to Verify

A. Deliverables:

Deliverable Acceptance Criteria
1 Deployed web app on Vercel Accessible at a public URL, all pages functional
2 GitHub repository with full source Clean code, working build, MIT license
3 Working xUDT token deployment User can create a token via wizard, tx confirmed on Testnet explorer
4 Wallet integration (multi-wallet) Connect/disconnect with JoyID, OKX, MetaMask via CCC
5 Token dashboard List deployed tokens, view detail, copy tx hash
6 Token transfer capability Send tokens between addresses, verify on explorer
7 Documentation README with setup instructions, architecture overview

B. How to Verify:

Deliverable Verification Steps Expected Output Environment
Web App Visit the Vercel URL Landing page loads, all routes navigable Any browser
Token Deployment Connect wallet → Create Token → fill form → Deploy Tx hash displayed, token appears on CKB Testnet Explorer with correct type script Browser and Testnet wallet with CKB
Wallet Connect Click “Connect Wallet” → select JoyID/OKX Wallet popup appears, address shown in UI Browser with wallet extension
Token List Navigate to /dashboard/tokens Mock and newly created tokens displayed with status badges Browser
Transfer Go to token detail → manage → transfer Tx confirmed on explorer, recipient balance updated Browser + two wallets
Repository Clone repo → npm install && npm run build Build succeeds with no errors Node.js 18+
Documentation Read README Clear setup steps, architecture diagram Any

Non-Code-Review Verification: All deliverables can be verified by visiting the deployed URL, connecting a wallet, performing token operations, and checking transaction hashes on the CKB Testnet Explorer, no code review required.

9. Current State vs. Funded Work

Current State (Completed):

  • Full UI component library: landing page (7 components), dashboard shell (sidebar, topnav, stats cards, token cards), token creation wizard (3 steps, deploy animation and success screen)

  • Zustand state management with localStorage persistence

  • Zod form validation schemas

  • Mock wallet connection and mock token deployment

  • Dark theme with Framer Motion animations

  • TypeScript, Next.js 16, Tailwind CSS v4 project setup

  • All routes wired and building successfully

Funded Work (Delta):

  • CCC SDK integration (replace mock wallet with real wallet connection)

  • Real xUDT token deployment via CCC SDK

  • Real token querying via CKB cell indexer

  • Token transfer functionality

  • Error handling for on-chain failures (insufficient capacity, tx rejected)

  • CKB balance display and fee estimation

  • End-to-end testing on Testnet

  • Documentation and demo preparation

10. CKB Alignment

Connection Points:

  1. xUDT Token Standard: CellMint directly implements xUDT token creation, the fungible token standard on CKB. The core deployment flow constructs xUDT type scripts using the creator’s Lock Script hash as the token identity.

  2. Cell Model: All token operations work with CKB’s UTXO-based cell model. Token amounts are encoded as 16-byte LE u128 in cell data. Deployment creates new cells with xUDT type scripts.

  3. CCC SDK Integration: Uses @ckb-ccc/connector-react for wallet connection and @ckb-ccc/core for transaction construction, aligning with the official CKB TypeScript SDK ecosystem.

  4. Multi-Wallet Support: Leverages CCC’s unified wallet interface to support JoyID, OKX, MetaMask, and other wallets, promoting CKB’s wallet ecosystem.

  5. CKB Testnet: All development and testing targets CKB Testnet (testnet.ckbapp.dev), encouraging developers to experiment risk-free before deploying to mainnet.

Honest Declaration: CellMint is fundamentally a CKB-native DApp. It cannot exist on any other blockchain, the xUDT standard, cell model, type scripts, and CCC SDK are all CKB-specific. The entire value proposition is making CKB’s token creation accessible to non-developers.

1 Like