Skip to content
kascov
explore playground API

Kaspa coins just learned to carry rules.

kascov watches every smart coin on the Kaspa testnet — born, moving, retiring — and saves the history the network deletes after 3 days.

the last 24 hours

how to read this

  1. Borna coin gets an identity and rules
  2. Movesit changes hands or state — identity travels with it
  3. Retiredits story ends, recorded forever here

new here? take the 30-second tour →

wait — what is a smart coin, really?

Normal KAS is like cash: interchangeable bills with no memory. Spend some, and brand-new bills come out the other side — nothing connects them to the old ones.

Since the Toccata upgrade, a transaction can take ordinary KAS from any wallet and wrap it into something new: an output stamped with a permanent identity (a covenant id) and, usually, a program. That moment is a birth — ordinary money becoming a named coin that carries rules. The id is a fingerprint of that exact moment, so it can't be faked.

When its owner spends it and the transaction stamps the same identity onto new outputs, that's a move: same coin, new state — maybe a new owner, maybe split into pieces, maybe merged back. The name travels with it, however many hands it passes through.

And when it's spent without passing the identity on, the KAS inside flows back out as ordinary cash and the identity ends — retired. The network forgets the whole story within days. kascov doesn't.

Why bother? Because the program travels with the identity: a coin can refuse to move more than 10% a week, demand two signatures, wait for a delivery confirmation, or verify a zero-knowledge proof — the coin itself enforces its rules, no middleman.

the latest stories

    open the explorer →

    script decoder

    paste any Kaspa script, read its post-Toccata opcodes — covenant ops highlighted. runs in your browser, nothing leaves the page.

    JSON API

    everything kascov sees, as plain JSON with CORS on. build a bot, a chart, a better explorer.

    make a smart coin

    deploy a real contract on testnet and watch it run itself — one command, no Rust knowledge needed. it reveals itself here, named forever.

    new here? how to read this →

    your coins — the ones you starred

    life on the testnet

    record holders

    what’s running here

    apps · coins that move together

    a single transaction moving several smart coins is a multi-contract flow — a covenant app.

    based-app activity · by namespace

    smart coins whose transactions carry an app payload, grouped by its namespace — the first per-namespace view of Kaspa's based apps.

    inscriptions · what’s being written on-chain

    the JSON payloads, decoded straight from the bytes — each covenant’s protocol, operation and token ticker, exactly as written. no registry, no labels we invented.

    app graph · coins that move together

    each cluster is an app — smart coins that shared transactions. click a dot to open the coin.

    how long do smart coins live?

    the lifespan of every retired coin — from birth to burn.

    latest stories

      all smart coins

      📄 read a script ✎ write a covenant

      read a script

      paste any Kaspa script as hex and read it as opcodes — including the post-Toccata set: transaction introspection (KIP-17), covenant ops (KIP-20), zk verification (KIP-16). recognizing, disassembling & linting run in your browser; simulate, verify-proof & compile call the kascov node. recognized contracts can be re-made with your own parameters.

      try an example:
      what the colors mean
      • push data pushed onto the stack
      • standard the classic script opcodes (checks, math, stack)
      • introspection KIP-17 — the script reads its own transaction
      • covenant KIP-20 — smart-coin identity & state rules
      • zk KIP-16 — zero-knowledge proof verification
      • unknown not in the post-Toccata opcode table
      📄 read a script ✎ write a covenant

      the lab

      Make your own smart coin.

      Deploy a real covenant on Kaspa testnet-10 and watch it run itself — no Solidity, no VM bytecode, just Kaspa script. One command births a contract and spends it under its own rules, and it reveals itself right here on kascov.

      cargo run -p kascov-lab -- escrow-demo click to copy

      write & compile SilverScript

      Write a covenant in SilverScript and compile it to real Kaspa script right here — powered by the actual silverc compiler. Edit the source, set the constructor args, and get deployable hex.

      start from a template:

      the whole loop

      1. 1
        Decoderead any covenant on-chain as SilverScript — its rules, its parameters, labeled.
      2. 2
        Editchange the constructor arguments in your browser; verified byte-for-byte on every keystroke.
      3. 3
        Deployone command births it on testnet — a real coin, its rules committed as a P2SH state.
      4. 4
        Spendsatisfy the contract's own rules; the transaction reveals the program on-chain.
      5. 5
        Revealedkascov names the coin its contract, forever — for everyone, hash-verified.
      ⌘ prefer the command line? run the whole loop from the CLI

      start here — one command

      You need the repo and a faucet-funded key. Then a single command runs the entire loop and prints a kascov link so you can watch it happen.

      escrow-demo

      An escrow is deployed with you as the arbiter, then you settle it — the contract itself forces the payout to the buyer. A real dispute resolution, on-chain.

      cargo run -p kascov-lab -- escrow-demo

      contract-demo

      A Mecenas is deployed reclaimable by your key, then reclaimed — it reveals itself as SilverScript · Mecenas on kascov, with every argument labeled.

      cargo run -p kascov-lab -- contract-demo

      examples

      Prints every copy-paste recipe — setup, the demos, and the manual decode → deploy → spend flow with your own parameters. Needs no key or network.

      cargo run -p kascov-lab -- examples

      the contracts you can make

      Three canonical SilverScript covenants ship with the decoder. Open one, put your own keys and amounts in, and it compiles to deployable hex in your browser.

      Mecenas

      A recurring allowance. A recipient may claim a fixed pledge every period; the funder can reclaim the rest at any time.

      🛠 make a Mecenas →

      Escrow

      Funds held for a trade. An arbiter releases them to the buyer or the seller — and the script enforces that the money can only go to one of them.

      🛠 make an Escrow →

      LastWill

      An inheritance switch. A hot key refreshes it; if it goes quiet long enough, an inheritor can claim — with a cold key as the override.

      🛠 make a LastWill →

      do it yourself, step by step

      01

      Get a key, fund it

      Make a throwaway testnet key and fund the address it prints at the faucet.

      cargo run -p kascov-lab -- keygen
      02

      Generate your contract

      On the decoder, click make a Mecenas / Escrow / LastWill, edit the fields (use the pubkey and blake2b that keygen printed), and copy the compiled hex.

      03

      Deploy it

      Births the coin as a hidden P2SH commitment. It appears on kascov within a minute.

      cargo run -p kascov-lab -- deploy --program-hex <hex> --value 1000000000
      04

      Reveal it — spend it

      Satisfy the contract to reveal its program on-chain, so kascov names it your contract forever.

      cargo run -p kascov-lab -- spend --program-hex <hex> --entrypoint reclaim

      Escrow instead? settle-escrow --program-hex <hex> --release-to buyer

      Full walkthrough in docs/Covenant Lab.md. Every command has --help.

      reference

      The kascov API.

      Every covenant on Kaspa, indexed live and kept long after nodes prune it — as plain JSON. No keys, no rate cards, CORS open to everyone. Build a bot, a chart, a better explorer.

      Start
      Overview Networks
      Feeds
      Live feed Full snapshot Event stream
      Coins
      One coin Transaction Address
      Analytics
      24h digest Templates Activity Apps Based-app lanes

      Overview

      The indexer follows Kaspa's chain tip live, classifies every covenant event (born / moved / retired), decodes spend-time script reveals, and serves the whole index as static JSON from a CDN. Reads are cheap and cacheable — poll as often as you like.

      Base URLhttps://kascov-explorer.web.app
      FormatJSON · application/json
      AuthNone — public
      CORSAccess-Control-Allow-Origin: *
      CachingCDN s-maxage + stale-while-revalidate; responses carry tip_daa + tip_at_ms so you always know how fresh they are

      Networks

      Every path takes a network segment. Swap testnet-10 for mainnet anywhere. Mainnet's first smart coins arrived July 2, 2026; their full history starts there.

      GET/data/{network}-live.json

      The small, fast feed — network stats, the chain tip, and the ~150 newest life events. This is the one to poll (a few KB, refreshes every few seconds).

      Request
      curl -s https://kascov-explorer.web.app/data/testnet-10-live.json
      Response · 200
      {
        "stats": { "covenants": 89747, "active": 6566, "events": 403794 },
        "tip_daa": 509571904,
        "tip_at_ms": 1751799000000,
        "processed_daa": 509571904,
        "recent_events": [
          { "covenant_id": "b11acf6c…459c6",
            "kind": "genesis", "txid": "a86041…e684",
            "accepting_daa": 508951007 }
        ]
      }
      FieldTypeNotes
      stats.covenantsintdistinct smart coins ever seen
      stats.activeintcoins with a live UTXO right now
      tip_daa · processed_daaintchain tip vs. last block applied — the gap is the honest sync lag
      recent_events[].kindstringgenesis · transition · burn
      GET/data/{network}.json

      The grid — stats plus one summary row per covenant. One request tells you about every smart coin on the network (can be multiple MB; cache it).

      Response · 200
      {
        "stats": { … },
        "covenants": [
          { "covenant_id": "b11acf6c…459c6", "name": "nimble-teal-newt-b11a",
            "status": "active", "born_value": 1000000000, "live_value": 1000000000,
            "event_count": 1, "genesis_daa": 508951007, "last_daa": 508951007,
            "template": "SilverScript · Mecenas" }
        ]
      }
      FieldTypeNotes
      statusstringactive or burned
      born_value · live_valueintsompi held at birth / right now
      templatestring?recognized contract, or a state shape like p2sh commitment
      GET/data/{network}/stream

      Server-sent events — one JSON message the moment the indexer sees each life event, plus a : ka keep-alive every 25s. Treat messages as hints and confirm through the polled feeds (some CDNs buffer streams).

      Request
      curl -N https://kascov-explorer.web.app/data/testnet-10/stream
      Each message
      data: {"covenant_id":"b11acf6c…","kind":"genesis",
             "txid":"a86041…","accepting_daa":508951007}
      GET/data/{network}/c/{covenant_id}.json

      One coin's whole life — the complete event timeline and every UTXO with decoded scripts, recognized templates, and spend-time reveals. 404 if the id is unknown.

      Response · 200
      {
        "covenant_id": "da2fe117…5d6d7", "name": "lively-slate-urchin-da2f",
        "status": "burned", "event_count": 2, "lineage_complete": true,
        "genesis_txid": "823d33…80c5", "genesis_daa": 509571333,
        "events": [
          { "seq": 0, "kind": "genesis", "txid": "823d33…80c5", "accepting_daa": 509571333 },
          { "seq": 1, "kind": "burn",    "txid": "1461f8…07ed", "accepting_daa": 509571520 }
        ],
        "utxos": [
          { "outpoint": "823d33…80c5:0", "value": 500000000, "live": false,
            "template": "p2sh commitment",
            "state_fields": [ { "name": "program_hash", "value": "d9a9e982…f475d17" } ],
            "revealed_template": "SilverScript · Escrow",
            "revealed_fields": [ { "name": "arbiter_hash", "value": "f4445661…" } ] }
        ]
      }
      FieldTypeNotes
      lineage_completeboolfalse means kascov started watching mid-life; earlier history is honestly missing
      utxos[].revealed_templatestring?the contract a P2SH state actually ran, decoded and hash-verified when it was spent
      …_fields[]array{ name, value } — labeled constructor arguments
      GET/data/{network}/tx/{txid}.json

      Which smart coin did this transaction touch? Genesis, moves and burns all resolve.

      Response · 200
      { "covenant_id": "b11acf6c…459c6" }
      Not covenant traffic · 404
      { "error": "not found" }
      GET/data/{network}/addr/{address-or-pubkey}.json

      Which smart coins has this address touched? Accepts kaspa:… / kaspatest:… or raw 32/33-byte pubkey hex. Matches p2pk covenant states.

      Response · 200
      {
        "address": "kaspatest:qp9…hzy0",
        "pubkey": "4b3402be…e9f2",
        "covenants": [
          { "covenant_id": "…", "name": "…", "role": "controls_now" }
        ]
      }
      FieldTypeNotes
      covenants[].rolestringcontrols_now · states_seen
      GET/data/{network}/digest.json

      The last 24 hours in one object — births, moves, burns, value born, the busiest coin, the biggest birth, and how many coins are alive. Refreshes about once a minute.

      Response · 200
      {
        "births": 24762, "moves": 25948, "burns": 55074,
        "value_born": 4831200000000, "alive": 6566,
        "busiest": { "covenant_id": "…", "name": "curious-jade-zebra-6366", "events": 1185 },
        "biggest_birth": { "covenant_id": "…", "name": "rapid-violet-seal-b788", "value": 937465200000000 }
      }
      GET/data/{network}/templates.json

      What runs on this network — recognized script templates aggregated over every state UTXO. Unrecognized scripts are counted, never hidden.

      Response · 200
      {
        "templates": [
          { "name": "p2sh commitment", "live_states": 6297, "live_value": 62970000000,
            "ever_seen": 14459, "covenants": 5990, "revealed_runs": 3 }
        ],
        "unrecognized": { "ever_seen": 12, "live_states": 4 }
      }
      FieldTypeNotes
      revealed_runsintcompiled contracts proven at spend time; a tx sweeping N states counts N
      GET/data/{network}/activity.json?range=24h

      The histogram behind the activity chart — life-event counts per DAA bucket. Empty buckets are omitted; treat them as zeros.

      QueryTypeNotes
      rangeenum1h · 6h · 24h · 48h · all (default 24h)
      Response · 200
      {
        "range": "24h", "bucket_daa": 6000,
        "buckets": [ { "daa": 509540000, "births": 812, "moves": 903, "burns": 1740 } ]
      }
      GET/data/{network}/families.json

      Covenant apps — clusters of coins that moved together in a transaction (multi-contract flows), union-found over shared txids. Each family lists its members with their recognized template.

      Response · 200
      {
        "families": [
          { "size": 2, "members": [
              { "covenant_id": "09ef275e…", "template": "p2sh commitment", "shared_txs": 8 },
              { "covenant_id": "901be291…", "template": "p2sh commitment", "shared_txs": 8 }
          ] }
        ]
      }

      Served by an always-on indexer that follows the chain live. Want the raw index or to run your own? github.com/Knitser/kascov.

      Kaspa nodes forget after ~3 days. kascov remembers.

      explorer · playground · JSON API & docs

      github.com/Knitser/kascov

      data streams live from the kascov indexer — it never stops watching

      not affiliated with the Kaspa Foundation