KasForge

KasForge is PumpForge's token launchpad built natively on Kaspa L1. Coins launch on a bonding curve, graduate into a pool with locked liquidity, and trade through covenant contracts. Everything is signed in the user's own wallet.

At a glance

How it fits together

1. Contracts on Kaspa L1 hold every coin's curve or pool, its tokens, orders, locks and streams. They enforce prices, fees and who may move what.
2. The sequencer settles orders in sequence, usually within seconds. It can only fill an order on the terms the user signed; it can never take funds. If it stops, orders can be cancelled by their owner and are refunded after about 60 minutes.
3. The API prepares every transaction for the user's public key and returns it unsigned with a cost summary. The user's wallet (or a bot's signer) signs; the API submits.
4. Data: markets, trades, candles, holders, a token list and DEX aggregator feeds are public.

Launch mechanism

Anyone can launch a coin from /launch or through the API (action: "launch"). A launch is two transactions, approved one after the other.

What the creator sets

Supply and identity

Every coin has a supply of 1,000,000,000 tokens with 0 decimals. A coin is identified by its token covenant id (64 hex characters, the KCC-20 id). Names and tickers are chosen by creators and are not unique: integrations should always key on the covenant id. Each launch's genesis transaction id is published so the id can be checked against the chain.

Anti-snipe (first minute)

For the first minute after launch one buy can take at most 1% of the supply (checked by the contract) and one wallet at most 1% in total (checked by the service). A larger buy is accepted as an order and settles when the minute is over. Market JSON shows antiSnipe.active.

Launch fee

When switched on, the launch fee is set in US dollars and charged in KAS at the current rate. The launch form and the cost summary show the exact amount before approval.

Trading and pricing

Trades are orders: the user locks KAS (buy) or tokens (sell) in an order contract with a minimum to receive; the sequencer settles it against the curve or pool.

Connect a wallet

Press Connect wallet and pick one. Every trade, launch, lock and stream is signed in your own wallet; KasForge never holds your keys or funds.

On testnet, set your wallet to Testnet 10 (addresses start with kaspatest:). KasForge asks Kasware and Kaspire to switch for you, and Kaspire's app switches on its own over WalletConnect. Install wallets only from their official sites; copycat extensions exist.

The bonding curve

The curve is constant product with virtual reserves. With x = virtual KAS + KAS raised and y = tokens left + virtual tokens:

price (KAS per token) = x / y
market cap           = price × 1,000,000,000
progress             = KAS raised / raise × 100

Buys push the price up, sells push it down. The virtual reserves are set from the chosen raise so that, at the raise, the curve has sold 80% of its tokens.

Orders and settlement

1. The user signs an order: KAS (plus a 1 KAS token deposit and a small settlement tip) or tokens go into the order contract, with a minimum to receive from the slippage setting.
2. The sequencer settles orders in sequence, usually within a few seconds. Bought tokens are added to the wallet's single balance of that coin.
3. If the price moved past the order's minimum, the order waits. The owner can cancel it any time; it is refunded automatically after about 60 minutes.

Limits

How fees are taken

Fees come out of the amount traded. A 100 KAS buy costs 100 KAS: the 1.5% fee and the 0.05 KAS tip are taken from it and the rest buys tokens. The refundable deposit and the network fee are on top. A sell pays its KAS minus the fee and tip.

Graduation

A coin graduates when its curve has raised the creator's chosen amount. Its liquidity moves into a pool and the coin keeps trading there.

80 / 20

• By the time the raise is reached, the curve has sold 80% of its tokens.
• The other 20% goes into the pool together with the KAS raised minus the 3% graduation fee, at the curve's last price. The price does not drop and nothing is burned at graduation.
• The graduation liquidity is locked permanently: nobody can withdraw it.

The buy that completes the raise

It buys the curve's last tokens at curve prices; any KAS beyond the target buys from the new pool in the same order. The quote shows both parts.

The pool

A constant-product pool (price = KAS / tokens). Anyone can add liquidity at the current ratio and receive pool shares (a KCC-20 token). 0.25% of every pool trade stays in the pool for providers.

Ids before and after

The coin keeps its token covenant id. The market moves from the curve covenant to a new pool covenant; market JSON shows kind (curve or pool), market (the live covenant), id (the curve id the coin was launched with) and graduation (ts, txid).

Fees and burns

A trade costs 1.5% wherever it happens. The split differs on the curve and in the pool.

Fee table

Creator fees

• The creator wallet (the launcher) never changes. It can share each claim with up to two other wallets, each with its own share.
• The fee authority may change the settings. It stays with the creator while the creator keeps any share; if the creator gives 100% away, it picks which receiver holds the authority.
• Creator fees are claimed by hand (from 0.2 KAS). One claim pays every wallet its share.

Buyback-and-burn

A share of the creator fees (0–100%) buys the coin on its curve or pool on the creator's schedule (every 5 minutes to 24 hours, default 10 minutes). A buyback runs one full interval after new fees arrive, so a trade never triggers an instant burn. The tokens bought stay locked inside the market for good. Market JSON reports fees.burnPct, fees.burnedTokens, fees.nextBuybackAt.

Protocol revenue

Platform fees accrue inside each market and are swept to the platform wallet automatically. On coins launched with v3.2 and later, the partners' revenue share is split out on chain in the same sweep.

Liquidity

Every graduated coin has a pool. Its graduation liquidity is locked; anyone can add liquidity of their own.

• Deposit KAS and the coin together at the pool's current ratio (lp-add). You receive pool shares, a KCC-20 token. More deposits add to the same position.
• Earn 0.25% of every pool trade, kept in the pool and shared by ownership. Nothing to claim.
• Withdraw any part (lp-remove): KAS and tokens at the current ratio.
• Risk: if the price moves, a withdrawal can be worth less than holding (impermanent loss). Fees may not make up for it.

Market JSON → liquidity: totalShares, lockedShares, providerShares, lpFeeBps, minDepositKas, tokensPerKas.

Locks, vesting and streams

Token locker

Lock tokens of any coin you hold for yourself or another wallet: a simple lock (one date), a cliff (up to three dates with their own shares) or linear (start, optional cliff, end). Only the receiving wallet can collect, and only after each date. Fee about $10 in KAS, plus about 1.2 KAS per date held with the lock and returned on collection. Every lock has a public page at /lock/<id>.

Payment streams

Stream KAS or any KasForge coin to a wallet, linearly between a start and an end (an hour to about 2,000 days), with an optional cliff. The receiver collects whenever they like. A cancellable stream can be stopped by the payer: the receiver keeps everything unlocked up to the block the cancel lands in, the payer gets the rest. Fee about $5 in KAS. Public page: /stream/<id>.

API: GET /streams, GET /stream/:id, and the build actions stream-create, stream-claim, stream-cancel, stream-settle.

Bubble map and chart markers

Every coin page shows who holds the coin, how those wallets are connected, and what the creator did on the chart, so you can judge a coin before you trade it.

Bubble map

Open a coin and pick the BUBBLE MAP tab. The map opens in its own window.

• Bubbles: the top 50 wallets. A bubble's area is its share of the whole supply, so hiding one never resizes the others.
• Links between holders: token transfers (solid line, read from Kascov's per-token history), KAS transfers (dashed line, from the Kaspa REST API), and a shared funder (dotted line to a small dot: one wallet sent KAS to several holders).
• Clusters: wallets joined by links share a colour and a total. Large shared sources such as exchanges are left out so they don't join everyone.
• Fresh wallets (🌱): a wallet whose whole KAS history starts less than 24 hours before its first trade in the coin.
• Creator (★) is marked on its bubble.
• Special holders start hidden but are always in the address list: the curve or pool, the dev vault, burned tokens, locks and vesting, and payment streams. Unhide the curve or pool to see who bought and sold on it.

Using the map

• Drag bubbles; they float, push each other, and stay where you drop them. Linked wallets follow the one you drag.
• Scroll, pinch or use + / − to zoom; ⤢ fits everything; Re-arrange lays the map out again.
• Click a bubble for its card: share, balance, cluster, every link, its trades on the curve or pool, a link to its profile.
• The address list (open by default on a computer) has search and an eye per row to hide or show a holder. Your choices are saved per coin.
• Balances refresh every 30 seconds while the map is open; links are rebuilt at most every 10 minutes. ↻ asks for both now.

Holders tab

The holder list shows the curve or pool, the dev vault and burned tokens on their own rows, and lists every payment stream, lock and vesting separately with the wallet it pays or unlocks to, so locked tokens are never counted as a wallet's free balance.

Chart markers

Turn them on and off under Indicators on the chart. Each marker sits at the trade's price on its candle; hover for the details and the transaction.

Several events in one candle become one marker with a count.

Verify on chain

You don't have to trust the site: every KasForge coin can be checked from the Kaspa chain itself.

The token is the official build

KasForge coins are KCC-20 tokens built from the official reference program, byte for byte, at the standard's Final text. Explorers that review that build recognise every KasForge coin as a standard token.

Names on chain

Each coin's name and ticker are written into its launch transaction in the KCC-23 format, so the token's id itself commits to them. Explorers show this as a verified name binding. Names are still not unique: always check the token id.

Kascov

Every coin page links to Kascov, the covenant explorer for Kaspa. For each coin it rebuilds the token's identity from its genesis, walks its whole history, and checks that the supply is conserved, then shows the coin as verified. It also lists where the supply sits: in wallets and in contracts.

Check it yourself

1. Copy the coin's token id from its page (the Details tab) or from the token list.
2. Open it on Kascov and compare the supply, holders and history with the coin page.
3. For an integration, follow Reference token.

How KasForge is tested

Every contract version goes through the same checks before it reaches the site.

• Kaspa's real consensus rules. Every action (launch, buys and sells, orders, fees, graduation, liquidity, locks, vesting, streams) runs through Kaspa's own transaction validation, the same code nodes run.
• The real signing path. Transactions are signed the way Kasware and Kastle sign them, input by input, and tested live on Testnet 10 with those wallets.
• Tampered transactions. A fuzzer takes honest transactions and attacks them: changed amounts and outputs, swapped inputs, extra mints, spending another user's tokens, fake contracts. More than 190,000 tampered transactions so far, and none was accepted that broke a rule.
• Mutation testing. The contracts are broken on purpose, one rule at a time, to prove the tests notice every missing check.
• Known attack patterns. The contracts were checked against every finding of a published security review of a similar Kaspa covenant project.
• Old coins keep working. Each new version runs the full suite on the earlier versions too, so coins launched on them keep trading.

Found something? Report it in #support on the PumpForge Discord.

Community takeovers

When a coin's community asks (for example after the creator leaves), PumpForge can move the coin's creator fees to a new wallet.

• Apply at /cto; you receive the policy and next steps by email.
• On v3.2+ coins the creator wallet itself stays; PumpForge gives 100% of the creator fees and the fee authority to the new wallet, keeping the buyback settings.
• Nothing else changes: not the tokens, not the pool, not the platform fees. Market JSON shows the latest takeover in cto (ts, txid, from, to).

Risk disclosures

• Testnet. KasForge runs on Kaspa Testnet 10. Settings may change, and test coins can be reset between contract versions.
• Smart-contract risk. The contracts are tested extensively (see How KasForge is tested), but no software is guaranteed free of bugs. Only use amounts you can afford to lose.
• Sequencer liveness. Orders need the sequencer to settle. It cannot take funds, but if it is down orders wait; owners can cancel and orders are refunded after about 60 minutes.
• Market risk. Coins are launched by their creators, not by PumpForge. Prices can go to zero. Names, images and links are the creators' and are not checked.
• Impermanent loss for liquidity providers.
• Lookalikes. Names and tickers are not unique; always check the token covenant id.
• Nothing in these docs is financial advice or a promise of returns.

Network and endpoints

Wallets

Wallets sign KasForge transactions input by input. Bots and servers sign with the SDK's signer (Schnorr, SIGHASH_ALL, BIP-340).

All of them return the signed transaction JSON, which goes to /submit unchanged.

Contracts

KasForge is a set of SilverScript covenant contracts on Kaspa L1. They hold every coin's market, tokens, orders, locks and streams, and enforce prices, fees and who may move what.

Versions

Ids

• Token covenant id (covenantId): the coin. Stable for life.
• Curve id (id): the market the coin launched with; also the coin's URL id.
• Market (market): the live market covenant (the curve, then the pool).
• Genesis (genesisTxid): the launch transaction that created the token id.

Every id in the API accepts either the token id or a market id. Contract details are available to integration partners and reviewers on request.

Reading token state

Everything a front end needs is in the market JSON from GET /markets (all coins) and GET /market/:id (one coin).

const r = await fetch('https://kaspa.pumpforge.tech/api/v1/market/' + TOKEN_ID);
const { market } = await r.json();
console.log(market.name, market.tick, market.priceKas, market.mcapKas, market.progress);

Key fields

Other reads

Trades, candles, holders, a wallet's account and portfolio: see Read endpoints. The token list for wallets and explorers: Token list.

Pricing and graduation math

Prices come straight from the reserves. Use /quote for exact trade estimates (fees, rounding and the curve/pool split at graduation included).

// curve (kind === 'curve'): virtual reserves included
price = (vKas + raisedKas) / (tokensLeft + vTokens)        // = market.priceKas
// pool (kind === 'pool')
price = pool.kas / pool.tokens
mcap  = price × supply                                      // = market.mcapKas
progress = raisedKas / targetKas × 100                      // = market.progress
graduation market cap ≈ market.graduationMcapKas

Fee math

platformFee = max(0.2, kas × feeBps / 10000)      // feeBps = 100 on the curve
creatorFee  = kas × creatorBps / 10000            // creatorBps = 50
// in the pool lpBps (25) of the platform fee stays with providers

Quote

GET /api/v1/quote/:id?side=buy&kas=100
GET /api/v1/quote/:id?side=sell&tokens=2500000

Returns receiveTokens or receiveKas, priceImpactPct, swapFeeKas, settleTipKas, tokenDepositKas, and for the buy that completes a raise completesRaise, curvePartKas, poolPartKas.

Token list

Every KasForge coin in the tokenlists.org shape, open to any origin.

Each entry: network, covenantId, symbol, name, decimals (0), logoURI and extensions (curveCovenantId, poolCovenantId, genesisTxid, graduationTxid, creator, supply, graduated, links, url). ?covenantId= returns one coin.

Reference token

A live coin to validate an integration against: read it from the API and compare with the explorer.

Check: the token id resolves in the token list, genesisTxid exists on the explorer, the price equals the reserves ratio, and its trades appear in the DEX feed.

API overview

One API for reading markets and for trading on behalf of users. The API prepares transactions; it never holds keys.

Open tier and partner keys

Partners may burst to 1.5× their limit for a moment and are served first when the service is busy. One end-user wallet can build at most 30 transactions a minute. GET /info returns the live tiers and rules.

Errors and limits

400 bad request, 401 key required, 429 rate limit (read Retry-After and X-RateLimit-Remaining), 503 busy (retry after a few seconds).

How a trade works

1. Build: POST /build with the action and the user's pub returns txs[] (each with txJsonString and signInputs), a buildId and a summary to show the user.
2. Sign every transaction in txs, in order: in the user's wallet, or on your server with the SDK.
3. Submit: POST /submit with { buildId, signed: [...] }. A build is valid for a few minutes.

Read endpoints

:id accepts a token id or a market id. Try them live with Run.

Every coin's market JSON (see Reading token state).

One coin.

Trade estimate.

Recent transactions (buys, sells, buyback burns, liquidity), newest first; limit up to 200. Each: ts, type, volume (KAS), tokens, price, txid, trader.

Candles: 1m 5m 15m 1h 4h 1d.

Holders including the curve or pool, the dev vault and burned tokens. Payment streams (stream: true, streamId, payer, receiver) and locks or vesting (lock: true, vesting, beneficiary, unlockDaa) are their own rows, listed under the contract's address.

A wallet on one coin: balance, open orders, locks, liquidity.

A wallet across all coins: positions, PnL, created coins, activity.

Payment streams.

One stream with its schedule and history.

Tiers, rules and the network.

Build and submit

Always: action, pub (x-only key, 64 hex). Most actions also take market (token or market id).

// response
{ "ok": true, "buildId": "…",
  "txs": [ { "txJsonString": "…", "signInputs": [ { "index": 0, "sighashType": 1 } ] } ],
  "summary": { "action": "order-buy", "payKas": 100, "receiveTokens": 2512340, "minTokens": 2437000, … } }

{ "buildId": "…", "signed": [ "<signed tx JSON>", … ] }  →  { "ok": true, "txid": "…" }

Websites: sign in the user's wallet

// keep the API key on YOUR server: proxy /build and /submit
const b = await myServer.build({ action: 'order-buy', pub, market, kas: 10, slippage: 3 });
const signed = [];
for (const t of b.txs) {
  // window.kaspire.signPskt takes the same argument
  signed.push(await window.kasware.signPskt({ txJsonString: t.txJsonString, options: { signInputs: t.signInputs } }));
}
const r = await myServer.submit({ buildId: b.buildId, signed });

Partner program

Trading bots, terminals, wallets and sites earn from the trades they bring. Sign up yourself at /partners: sign in with Kasware, Kastle or Kaspire (one signed message, no fee), pick an id, get API keys (up to 3).

Two fee modes

Switch modes once every 30 days. Trades are tagged kfref:<your-id> on chain and show your name under “Via” on KasForge.

Claims

Claim from the partner dashboard from 1,000 KAS (testnet), or 30 days after your last payout. Claims are usually paid straight away from the payout wallet.

Your volume, earnings, balance, tier, limits and usage (needs your key).

Integration types

• Websites and terminals: build on your server, sign in the user's wallet, submit. Non-custodial.
• Telegram and Discord bots: sign on your server with the SDK. The bot holds its users' keys and is responsible for them.
• Wallets: build with the user's public key, sign inside the wallet, submit.
• Read-only tools: charts, scanners, trackers: read endpoints and feeds.

JavaScript SDK

@kasforge_official/sdk: an API client, a local signer and a transaction checker. Node 18+, MIT.

npm install @kasforge_official/sdk

Quick start

import { KasForge, trade } from '@kasforge_official/sdk';
const kf = new KasForge();                                  // open tier
// const kf = new KasForge({ apiKey: process.env.KASFORGE_API_KEY });  // partner
const r = await trade(kf, { action: 'order-buy', market: TOKEN_ID, kas: 10, slippage: 3 }, userKeyHex,
  (summary) => confirmWithUser(summary), { maxSpendKas: 11.1 });

Client methods

Signer

signTransaction(txJsonString, signInputs, privateKeyHex) signs the listed inputs (Kaspa Schnorr sighash, SIGHASH_ALL, BIP-340), checked against rusty-kaspa test vectors. sighash(tx, index) and publicKeyOf(key) are exported too. Keys never leave your process.

trade()

trade(client, body, privateKeyHex, confirm?, guard?) builds, calls confirm(summary), runs checkTransaction with guard (maxSpendKas, allowRecipients, allowCovenantInputs), signs every transaction and submits.

Example: a payment stream

const end = Math.floor(Date.now() / 1000) + 30 * 86400;
await trade(kf, { action: 'stream-create', receiver: 'kaspatest:…', amount: 300, end, memo: 'October' }, userKeyHex);

Check before signing

Never sign from the summary alone. checkTransaction(txJsonString, signInputs, { pub, maxSpendKas, allowRecipients, allowCovenantInputs }) enforces three rules from the transaction itself.

1. Every input the user signs is the user's own plain coin, unless allowCovenantInputs (sells, cancels, liquidity, locks, token streams).
2. No plain-address output pays anyone but the user (change), unless listed in allowRecipients.
3. The user's coins in minus plain outputs back to the user is at most maxSpendKas.

Spending caps per action

Exact input and output layouts per action are in the SDK's SPEC.md.

Holder map data

The data behind the bubble map: the top holders of a coin and the links between them. Public, no key.

Links are built from Kascov's token history and the Kaspa REST API, and cached for 10 minutes per coin. Balances come from /holders.

DEX aggregator feeds

KasForge publishes its swaps and liquidity events in the formats DEX aggregators read: the GeckoTerminal / DEX Screener events API and the CoinGecko DEX API. Open to any origin, no key.

Blocks on Kaspa

Kaspa is a blockDAG with about 10 blocks a second, so there is no single block height. The feed's blockNumber is a DAA-score clock: anchored once to the node's DAA score and advancing 10 per second. Every event carries the block of the second it was recorded in, so numbers never change and only grow. txnId is the real Kaspa transaction; use it to locate an event on chain.

Pairs and assets

• Each coin has two pairs over its life: its bonding curve (pair id = the curve id) and, after graduation, its pool (pair id = the pool covenant id).
• asset0 = the coin (its token covenant id, 0 decimals), asset1 = KAS.
• priceNative = KAS per token. Amounts are decimal strings. Reserves after each event are included (on the curve they include the virtual reserves that set the price).

GeckoTerminal / DEX Screener events API

{ "block": { "blockNumber": 412398120, "blockTimestamp": 1792490000 } }

{ "asset": { "id": "3846…1384", "name": "Nova", "symbol": "NOVA", "decimals": 0,
  "totalSupply": "1000000000", "circulatingSupply": "412900000", "metadata": { … } } }

{ "pair": { "id": "…", "dexKey": "kasforge-pool", "asset0Id": "<token id>", "asset1Id": "KAS",
  "createdAtBlockNumber": …, "createdAtBlockTimestamp": …, "createdAtTxnId": "…", "creator": "kaspatest:…", "feeBps": 150 } }

Inclusive range, at most 7 days wide. Event types: swap (buys, sells, and buyback burns with metadata.burn), join and exit (liquidity).

{ "events": [
  { "block": { "blockNumber": 412398050, "blockTimestamp": 1792489993 }, "eventType": "swap",
    "txnId": "…", "txnIndex": 0, "eventIndex": 0, "maker": "kaspatest:…", "pairId": "…",
    "asset1In": "250", "asset0Out": "1371428", "priceNative": "0.000182",
    "reserves": { "asset0": "…", "asset1": "…" } },
  { "eventType": "join", "amount0": "5000000", "amount1": "90", … } ] }

CoinGecko DEX API

[{ ticker_id: "<token id>_KAS", base, target: "KAS", pool_id }]

ticker_id, base_currency, target_currency, pool_id, last_price, base_volume and target_volume (24h), liquidity_in_kas, liquidity_in_usd, high, low.

{ buy: [...], sell: [...] }, each with trade_id (txid), price, base_volume, target_volume, trade_timestamp (ms), type. Times in ms or seconds; limit up to 1,000.

Caching

Responses are cached for 2 to 60 seconds. Poll latest-block, then request events from your last block + 1.

Support and terms

• Discord: #support on the PumpForge Discord (screenshot, time and what you clicked).
• Partners: sign up at /partners; for higher limits or a self-built integration, contact us there.
• Safety: the team never DMs first and never asks for a seed phrase or private key. Only use addresses ending in .pumpforge.tech.

Versioning

The API is versioned in its path (/api/v1). Contract versions are reported per coin (contracts). Older coins keep working on their own contracts.

Attribution

When you show KasForge data, link the coin to https://kaspa.pumpforge.tech/coin/<token id> and label it “KasForge”. Coins are launched by their creators, not by PumpForge.