Forge

Create and share your own tokens on the Kaspa network.

Forge is the simplest way to launch a KCC20 token on Kaspa. Name it. Set a ticker. Choose a supply. That's it — no code, no contracts, no waiting. Every token is a real, on-chain asset, created through the Silverscript covenant compiler and signed in your own wallet.

Try the live app: https://forge-jbu3.onrender.com/

Table of Contents

• Features
• How it works
• Usage
  • Create a token
  • Share a token
  • Look up a token
• Requirements
• Running locally
• Configuration
• Testing
• Contributing
• Good to know

Features

• Token creation in minutes — three fields, one button, done.
• Self-custody — transactions are signed in your Kasware wallet. Your keys never leave your browser.
• Shareable token pages — every token gets its own page and a link you can send anywhere.
• On-chain by design — fixed supply, owned by you, verifiable on the Kaspa explorer.
• Mainnet and testnet-10 — the network is detected automatically from your wallet.
• Your tokens, always — the "Your tokens" list lives in the cloud, so it survives restarts and idle spin-down.

How it works

Three steps.

1. Connect your wallet. Forge uses the Kasware wallet, right in your browser. One click, and you're connected.
2. Create your token. Give it a name, a ticker, and a total supply. Forge builds everything for you. You just review and sign.
3. Share it. Your token gets its own page. Copy the link. Send it anywhere.

Usage

Create a token

Fill in three things:

• Token Name — what your token is called.
• Ticker — its short symbol, like KAS.
• Total Supply — how many exist.

Press Create Token. Forge prepares the transaction. Review it in Kasware and confirm. Moments later, your token is on-chain.

That's it. You're a creator.

Share a token

Every token you create gets a page of its own.

It shows the name, the ticker, the supply, who created it, and when. Copy the link and send it to anyone — they don't need an account. They don't need a wallet. They just open the link.

Your tokens stay in your list, too. Whenever you connect your wallet, they're right there.

Look up a token

Have a token link? Open it.

Forge shows you everything about the token and links straight to the Kaspa explorer, so you can see it confirmed on the blockchain. Still pending? Forge keeps checking until it's confirmed. You don't have to do a thing.

Requirements

• The Kasware wallet — Kaspa's official browser wallet. If you don't have it, Forge points you right to it.
• A little Kaspa — just enough to cover the network fee and the token's locked deposit.

Running locally

Forge is open source. Run your own copy with nothing but Docker — no Node.js, no Rust, no Python on your machine. The image builds the covenant compiler (silverc), the frontend, and the backend, then serves everything from a single container on port 3001.

git clone <this-repo-url> forge
cd forge
docker compose up --build

Open http://localhost:3001, connect your Kasware wallet, and create your first token.

• Stop: docker compose down
• Rebuild after a code change: docker compose up --build
• No docker compose? The standalone docker-compose command works the same.

Dev and production are the same image — the only difference is configuration (see below).

Configuration

Everything works with sensible defaults. Set these in a root .env file (Compose picks it up) or in your shell before docker compose up:

Variable	Default	Description
PORT	3001	Where the API listens
LOG_LEVEL	info	Log verbosity (trace to fatal)
TOKEN_STORE_PATH	data/tokens.json	Where your created tokens are saved
TURSO_DATABASE_URL	unset	Turso database URL. When set, token records are stored in Turso instead of the local file, so the "Your tokens" list survives Render's free-tier spin-down
TURSO_AUTH_TOKEN	unset	Turso database auth token (required for libsql:// URLs)
CORS_ORIGINS	http://localhost:3001	Comma-separated list of allowed browser origins for the API. Requests without an Origin header (same-origin, curl) are always allowed

Testing

All tests run inside the image.

Unit tests (no running server needed):

docker compose run --rm forge npm test                            # backend
docker compose run --rm -e NODE_ENV=test forge npm --prefix ../frontend test   # frontend

End-to-end tests hit the running app, so start it first, then point the suite at the forge service on the compose network:

docker compose up -d
docker compose run --rm -e E2E_BASE_URL=http://forge:3001 forge npm run test:e2e
docker compose run --rm -e FORGE_E2E_BASE_URL=http://forge:3001 forge npm --prefix ../frontend run test:e2e

Contributing

Bug reports and feature suggestions are welcome via the GitHub issue tracker. Pull requests are reviewed and appreciated. Please make sure tests pass before submitting.

Good to know

• Forge works on Kaspa mainnet and testnet-10 (other Kaspa testnets are not supported). The network is shown right on your screen.
• Your token's supply is fixed from the start. It can't be changed, and it can't be inflated.
• Tokens are real assets on the Kaspa blockchain. When you create one, you own it.