Build on KaspaRocket

npm install @kasparocket/sdk

import { KaspaRocket } from "@kasparocket/sdk"       // ESM
const { KaspaRocket } = require("@kasparocket/sdk")  // CommonJS

// Bot, backend, scheduled job
new KaspaRocket({ apiKey: process.env.KR_SECRET_KEY })   // kr_live_…

// Site, extension, wallet
new KaspaRocket({ apiKey: "krpub_live_a3f2c1d0_…" })     // in the bundle, by design

import { KaspaRocket, kasToSompi, formatKas } from "@kasparocket/sdk"

const kr = new KaspaRocket({
    apiKey: process.env.KR_SECRET_KEY,
    network: "testnet-10",   // the only network deployed today
})

// No host to configure: one origin serves both APIs — transactions under
// /pro-api, the catalogue under /api. Override with `apiUrl` and
// `catalogueUrl` only if you run your own instance.

// 0 — Resolve the pool. Every trading call needs `lpCovenantId`, and neither
//     token route carries it: it lives on the covenant, not the token record.
const pool = await kr.catalogue.poolCovenant(tokenId)
if (!pool) throw new Error("this token has no pool yet")
const lpCovenantId = pool.lp_amm_covenant_id

// 1 — Quote. Commits nothing.
const quote = await kr.quote({
    tokenId, lpCovenantId,
    direction: "buy",
    kasBudgetSompi: kasToSompi("100"),
})
// `amountTokens` is in RAW units (1000 = 1 token) — display `amountTokensDisplay`.
console.log(`${quote.amountTokensDisplay} tokens, ${formatKas(quote.fee.total)} KAS in fees`)

// 1b — On a SELL, show `netKasSompi`, not the gross flow. It is what the user
//      pockets, fees deducted, and it can be NEGATIVE: selling 1,000 tokens can
//      return 0.12 KAS against a 3 KAS fee floor.
if (quote.uneconomic) {
    return refuse("this sale costs more in fees than it returns")
}

// 2 — Preview the route. This is what you show the user.
const preview = await kr.route({
    tokenId, lpCovenantId, address,
    side: "buy", kind: "market",
    budgetSompi: kasToSompi("100"),
})

// 3 — Build, carrying the preview's commitment.
const plan = await kr.planTrade({
    tokenId, lpCovenantId, address,
    side: "buy", kind: "market",
    budgetSompi: kasToSompi("100"),
    expected: preview.attendu,
})

// 4 — Sign and broadcast. Your key never touches our code.
await kr.signAndSubmit(plan, mySigner)

kasToSompi("1.5")        // 150000000n
formatKas(150_000_000n)  // "1.5"

import { toJsonSafe, formatKas } from "@kasparocket/sdk"

await redis.set(key, JSON.stringify(toJsonSafe(quote)))
bot.sendMessage(id, `Fee: ${formatKas(fee.total)} KAS`)

fee.total / 2n   // arithmetic stays in bigint

import { formatTokens, tokensToRaw, tokenPriceSompi, formatKas } from "@kasparocket/sdk"

formatTokens(5_000_000n)    // "5000"      — not "5000000"
formatTokens(1n)            // "0.001"     — one raw unit is not nothing
tokensToRaw("1.234")        // 1234n
tokensToRaw("0.0009")       // 0n          — below one raw unit, TRUNCATED

// A PRICE scales the other way: sompi per RAW unit, so multiply.
formatKas(tokenPriceSompi(23_000n))   // "0.23" per token

const quote = await kr.quote({ tokenId, lpCovenantId, direction: "buy", kasBudgetSompi })

quote.amountTokens          // 1234567n    — raw: arithmetic, comparisons, planTrade
quote.amountTokensDisplay   // "1234.567"  — what the user reads

// Before SDK 0.1.6, same result:
formatTokens(quote.amountTokens)   // "1234.567"

import {
    instructionsToSign, scriptP2pkh, spliceCovenantSignature,
} from "@kasparocket/sdk"
import type { Signer, PlannedTransaction } from "@kasparocket/sdk"

const mySigner: Signer = {
    getAddress: () => address,
    async sign(planned: PlannedTransaction) {
        // Every input that needs a signature — both kinds, never the "final" ones.
        for (const instruction of instructionsToSign(planned)) {
            const input = planned.tx.inputs[instruction.inputIndex]
            // Your job: a raw 65-byte signature over this input's sighash.
            const signature = await mySignature(planned.tx, instruction.inputIndex)

            input.signatureScript = instruction.kind === "p2pkh"
                ? scriptP2pkh(signature)                              // write a new script
                : spliceCovenantSignature(instruction, signature)     // splice into the prebuilt one
        }
        return planned.tx
    },
}

const plan = await kr.planCreateOrder({
    address, tokenId, lpCovenantId,
    side: "sell", priceSompi: kasToSompi("0.000033"), tokens: 9_000_000n,
})

// signAndSubmit forwards `plan.order_row` for you.
await kr.signAndSubmit(plan, mySigner)

// Calling submit() yourself? Pass it as the second argument.
await kr.submit([signedTx], plan.order_row)

const { tokens } = await kr.catalogue.feed({ limit: 10 })

for (const t of tokens) {
    const badge = t.placement === "sponsored" ? " · Sponsored"
                : t.placement === "skin"      ? " · Featured"
                : ""
    bot.send(`$${t.ticker}${badge} — ${t.volume_24h_kas.toFixed(0)} KAS traded`)
}

// Detection: everything created after an instant, OLDEST FIRST.
let since = new Date(Date.now() - 3600_000).toISOString()

for (;;) {
    const page = await kr.catalogue.feed({ since, limit: 50 })
    for (const t of page.tokens) await snipe(t)

    // null when nothing new came back — keep the cursor you had, or you would
    // skip whatever is minted between this call and the next.
    since = page.next_since ?? since

    // Still behind after a burst? Loop again before sleeping.
    if (page.pagination.total_count > page.tokens.length) continue
    await sleep(5_000)
}

// What it costs right now — dynamic, and commits to nothing.
const prices = await kr.catalogue.adPricing(tokenId)
console.log(prices.price_60_min, "KAS for an hour")

const plan = await kr.planSponsor({ address, tokenId, durationMinutes: 60 })
await kr.signAndSubmit(plan, mySigner)   // forwards `sponsor_row` for you

const pool = await kr.catalogue.poolCovenant(tokenId)
if (!pool) return                       // no pool yet — nothing to buy

// Who holds what. allHolders lifts the 25-row display cap.
const s = await kr.poolStats(pool.lp_amm_covenant_id, tokenId,
                             { points: 0, allHolders: true })

if (s.holders_truncated) return         // incomplete list — do not conclude from it

const total = s.holders.filter(h => !h.is_lp_pool)
                       .reduce((n, h) => n + Number(h.amount), 0)
const dev   = s.holders.find(h => h.address === token.creator)
const part  = dev ? Number(dev.amount) / total : 0      // the creator's share

const p = await kr.protocol()
p.partner?.feeAddress   // your address, as registered
p.partner?.scopes       // what your key may call
p.fees                  // the schedule in force for you

kr.estimateFees(kasToSompi("1000"))
// { treasury: 1000000000n, partner: 500000000n, total: 1500000000n }

// 1 — Open a session. Nothing is deployed, nothing is charged.
const session = await kr.tokens.createSession({
    creatorAddress: userAddress,   // who will own the token
    name: "Rocket Coin",
    ticker: "RKT",
    description: "…",
    imageUrl: "https://…",
})

// Show the user what to send, and where.
console.log(formatKas(session.amountSompi))       // "150"
console.log(formatKas(session.platformFeeSompi))  // "100" — the deployment
console.log(formatKas(session.partnerFeeSompi))   // "50"  — yours
console.log(session.depositAddress)

// 2 — Wait for the transfer.
const { balance_sompi } = await kr.tokens.depositBalance(session.sessionId)

// 3 — Deploy, streaming each step.
const result = await kr.tokens.run(session.sessionId, (event) => {
    if (event.message) bot.sendMessage(chatId, event.message)
})

console.log(result.status)      // "completed"
console.log(result.tokenId)     // the token id — trade it, list it, link to it
console.log(result.lpCovenantId) // its pool, needed by quote / swap / poolStats

import { KaspaRocketError } from "@kasparocket/sdk"

try {
    await kr.planTrade({ /* … */ })
} catch (e) {
    if (e instanceof KaspaRocketError) {
        if (e.kind === "rate_limit") await sleep(e.retryAfterMs ?? 1000)
        if (e.retryable) return retry()
        report(e.kind, e.message)
    }
}

// The pool of a token. Start here — see Quickstart.
const pool = await kr.catalogue.poolCovenant(tokenId)   // CovenantRecord | null
await kr.catalogue.covenants(tokenId)                   // the raw list

// A flat ARRAY, not an envelope. The route currently ignores paging.
const tokens = await kr.catalogue.tokens()              // TokenRecord[]
const token  = await kr.catalogue.token(tokenId)        // the DETAIL shape
await kr.catalogue.search("rocket")
await kr.catalogue.sections()

// Paginated routes, each with its OWN payload key.
const { comments, pagination } = await kr.catalogue.comments(tokenId)
const { items }                = await kr.catalogue.activity(address)
const { tokens: rows }         = await kr.catalogue.analytics({ page: 1 })

// The championship: levels and standings in one call.
const c = await kr.catalogue.championship()
nextLevel(c.levels, c.tokens[0])                        // the level being aimed at

const { limits } = await kr.protocol()
if (tokens * priceSompi < limits.minOrderValueSompi) {
    return refuse("order below the minimum value")
}