The prediction market
that settles on chain.
KOM is a prediction market protocol built natively on Kaspa Layer 1. Every bet is a covenant. Every resolution is a transaction. No bridge, no L2, no IOUs — just real KAS, locked by code, released by an oracle-witnessed proof.
on Kaspa
covenant
or L2s used
settlement
Why prediction markets need a new venue.
Prediction markets are the most useful financial instrument almost no one uses. They aggregate information better than polls, faster than journalists, and more honestly than pundits. Polymarket proved the demand. Kalshi proved the regulatory path. But both run on top of payment rails that require trust — trust in a custodian, trust in a centralized matching engine, trust that the platform won't change the rules after you've placed your bet.
The crypto-native version of this product has been attempted many times — on Ethereum, on Polygon, on every L2 chasing the next narrative. Most of them fail for the same reason: the chain underneath was never designed for sub-minute markets settling in real time. Block times are too slow. Gas costs eat small bets alive. MEV bots front-run resolutions. Bridges introduce trust assumptions that defeat the whole point.
KOM exists because Kaspa changes the underlying math. One-second finality. No MEV by design. Native Layer-1 covenant scripting. A blockDAG that processes transactions in parallel instead of sequentially. The chain that was missing for this product class finally exists — and KOM is built to take advantage of every property of it.
What KOM is.
KOM is a binary prediction market protocol. Users bet on yes-or-no outcomes — will KAS be above $0.0304 at 09:35 UTC? — by locking KAS into per-market covenant addresses on Kaspa. When the market closes, an oracle-witnessed transaction sweeps the losing side's pool pro-rata to the winners. No off-chain accounting. No custody intermediary. The pool you see on chain is the pool that pays out.
On-chain, end to end
Every bet is a Kaspa transaction. Every resolution is a Kaspa transaction. The pools are real UTXOs at addresses you can verify in any block explorer. The protocol doesn't need a database for custody — the chain is the database.
Designed for real-time markets
Kaspa's one-second finality unlocks market windows that don't work on other chains. KOM ships with auto-rolling 5-minute, 15-minute, and 60-minute markets across KAS, BTC, and ETH — refreshing every minute, settling within seconds of expiry.
No bridge, no L2, no IOU
KOM doesn't wrap your KAS or issue receipt tokens that represent a claim on a custodied pool. It uses Kaspa's native covenant language (Silverscript) to enforce the bet contract at the script level. The KAS in the pool is the KAS that pays you.
The rest of this page walks through how the protocol actually works — the architecture, the on-chain primitives, the bet lifecycle, and why we believe Kaspa is the right base layer for this. If you want the short version: it's covenants, oracles, and a blockDAG fast enough that the entire bet-resolve cycle fits inside a five-minute window. If you want the long version, keep reading.
A different model from Polymarket.
This is the part that trips people up, so it's worth being precise. KOM and Polymarket look similar on the surface — bet yes or no, get paid if you're right — but the machinery underneath is fundamentally different. Polymarket runs an order book. KOM runs a pool.
Polymarket — order book
You buy YES shares from someone selling them. Price is set by matching buyers and sellers, and each share pays $1 if it resolves your way. Every trade needs a counterparty on the other side. The platform's matching engine sits in the middle, off chain.
KOM — parimutuel pool
Everyone betting YES adds KAS to the YES pool. Everyone betting NO adds to the NO pool. There's no order matching and no per-trade counterparty — you're betting against the pool, not against a person. The two pools sit on chain as covenant UTXOs anyone can verify.
How pool funding works
When you place a 5 KAS bet on YES, that 5 KAS goes into the YES BetLock pool. Nothing is wrapped, nothing is lent, nothing is matched. Your stake just sits in the pool until the market closes. At settlement the rule is simple:
totalPot = winPool + losePool
payable = totalPot − txFee // txFee ≈ 0.0002 KAS, on-chain only
// the entire payable pot is split across the winning side, pro-rata to stake
yourPayout = (yourStake / winPool) × payable
The losing pool is swept to the winners in a single oracle-witnessed transaction, divided in proportion to how much each winner staked. KOM takes no rake — the only deduction is the network's own transaction fee, a fraction of a cent shared across the payout. Your profit is, quite literally, your slice of the money the losing side staked.
What if there are no losers?
This is the edge case worth understanding, because a pooled model has to answer it cleanly. Suppose a market closes and every bettor was on the winning side — the losing pool is empty. There's nothing to distribute, because no one was wrong. So the math does exactly what you'd hope:
Losing pool is empty
losePool = 0, so payable = winPool − txFee. Each winner gets back their own stake, minus a negligible shared network fee. No winnings — there was nothing to win — but no loss either. KOM never takes a rake on a refund.
You're the only bettor
Same rule, smallest case: if you're the sole bettor on the winning side, you simply get your stake back. The protocol can't manufacture a profit out of an empty opposing pool — and it doesn't pretend to. Your KAS was never at risk to anyone but the other side.
This is a direct consequence of the model being honest: in a real parimutuel pool, winnings come only from the losing side's stake. No losers means no winnings — and crucially, no phantom fees, no house edge eating an uncontested bet. The pool you can see on chain is exactly the pool that pays out.
How markets resolve.
A prediction market is only as trustworthy as the thing that decides who won. KOM's resolution layer is built around a single principle: the oracle should refuse to sign unless the data behind the outcome is genuinely reliable. It's not enough to read one price and pay out — the protocol cross-checks, gates on confidence, and waits.
Two independent sources, cross-checked
For crypto markets, KOM doesn't trust a single venue. The closing measurement is cross-checked across two independent exchanges — Coinbase and Kraken — and the oracle only acts on a price the two venues agree on. A single exchange can wick, lag, or be manipulated for a moment; two unrelated venues agreeing is a far harder thing to fake. For weather markets, the equivalent source is a meteorological data feed, read once at resolution to settle every temperature bucket at that close.
Crypto markets
KAS, BTC, ETH price outcomes are settled against Coinbase + Kraken, cross-checked. The two feeds must agree before the oracle will sign the resolution.
Weather markets
Temperature outcomes are read from a meteorological feed at the market's close. The oracle reads the value once and settles every bucket in that window against it.
The confidence gate
Before the oracle signs anything, the measurement passes through a confidence gate. If the data source has fallen back to anything other than a live, cross-checked feed — a cached value, a demo source, a single venue that lost its counterpart — the gate blocks the signature. No live data, no resolution. The market simply stays open for settlement until reliable data is available again. The oracle's only real risk is mis-resolving from bad data, so the system is designed to fail closed: it would rather wait than sign on a number it doesn't trust.
Propose, wait, finalize
Resolution isn't a single instantaneous act. It runs in three phases, preserving a window for scrutiny before money moves:
The oracle proposes an outcome from the cross-checked data, a challenge window elapses during which the proposal can be scrutinized, and only then does the oracle finalize — signing the settlement transaction that the BetLock covenant requires. Remember: the covenant won't release a single sompi without a valid oracle signature, so this is the one gate every payout must pass.
The trust model, stated honestly
On testnet today, the oracle is a single authorized key — the holder of the schnorr private key matching the oraclePubkey baked into each BetLock at compile time. We don't dress this up: v1 is an honest single-oracle model, gated by cross-checked data and a challenge window, but ultimately one signer. The covenant is oracle-gated, not trustless, and we'd rather say so plainly than overclaim.
The mainnet path replaces that single key with a multi-signature oracle — a set of independent price providers, with a formal dispute window before final settlement. Because the covenant only checks for a valid signature against a baked-in pubkey, upgrading from one signer to a multi-sig is a change in who holds the key, not a rewrite of the contract. The final design will be locked and published in the whitepaper before mainnet launch.
Architecture.
KOM is four moving pieces: a browser client where users sign their own bets, a Next.js server that derives addresses and forwards transactions, the Kaspa testnet node that holds the canonical state, and a 60-second cron that creates new markets and settles closed ones. The browser never sees the server's keys. The server never sees the user's keys. The chain mediates everything.
| Layer | Owns | Doesn't own |
|---|---|---|
| Browser | Wallet keys (IndexedDB, never sent), tx signing, live price feed, UI state | Anything that must survive a refresh |
| Next.js server | Market registry, position store, address derivation, tx forwarding | Wallet keys (must never reach the server) |
| kaspad | Source of truth for every balance and transaction | Application metadata (questions, strikes, close times) |
| launchd cron | Heartbeat for market creation and settlement | State — it just calls HTTP endpoints |
BetLock & ShareToken.
A KOM market is made of two on-chain primitives: BetLock covenants that hold the stake pool, and ShareToken UTXOs that prove ownership of individual positions. They're separated because the pot needs to be sweepable by the resolver in a single transaction, while ownership has to remain attributable per-bet. One pot, many receipts.
BetLock — the per-side pool
Each market deploys a fresh pair of BetLock covenants — one for YES, one for NO — compiled at market-creation time using Kaspa's Silverscript covenant language, with three constructor arguments:
sideByte: byte // 1 = YES, 2 = NO
oraclePubkey: byte[32] // x-only schnorr key authorized to settle
The compiled output is a 65-byte script that produces a unique kaspatest:… address. Every bet on the YES side of a market lands at the same YES address; every NO bet at the sibling. Together the two addresses are the market's pot — verifiable by anyone on a block explorer. The script enforces a single rule: this UTXO can only be spent by a transaction including a valid oracle signature attesting to the outcome. No oracle signature, no spend. That's the entire contract.
ShareToken — the per-bet receipt
Every bet creates a second covenant UTXO holding 2 KAS (Kaspa's minimum-UTXO dust) at a ShareToken address keyed by (ownerPubkey, marketId, side, shareAmount). This is your proof-of-bet, spendable two ways: by you, with your schnorr signature, to redeem winnings or list on the secondary market; or by the settlement transaction at maturity, which consumes losing-side ShareTokens in the pro-rata payout. Because the receipt is on chain and tied to your pubkey, your position is recoverable from any wallet — you don't need KOM's frontend to claim.
A single bet transaction
When you place a bet, KOM constructs one transaction with three outputs:
↓
OUTPUT 0: BetLock covenant address (5 KAS stake)
OUTPUT 1: ShareToken covenant address (2 KAS receipt)
OUTPUT 2: Change back to your wallet (~92 KAS − fees)
One transaction. Three outputs. Two land at on-chain covenant addresses you can inspect; the third is your change. The transaction is signed entirely in your browser — your private key never leaves your device. The server only forwards the signed bytes to kaspad.
Bet lifecycle.
Here's exactly what happens when you click YES on a market. Five steps, all visible in your browser's network tab, all ending in a single transaction that lands on chain within ~1 second.
| # | Step | What happens |
|---|---|---|
| 1 | Address derivation | Client requests the BetLock YES/NO addresses for the marketId; picks the one matching the chosen side. |
| 2 | ShareToken compilation | Server compiles a ShareToken script from owner pubkey, marketId, side, share amount; returns its address. |
| 3 | UTXO fetch | Client queries its own wallet UTXOs, finds the smallest set covering stake + 2 KAS dust + fee. |
| 4 | Tx construction | Client builds the multi-output transaction via kaspa-wasm. All signing is local — keys never leave the browser. |
| 5 | Submission | Signed tx hex is forwarded to kaspad's submitTransaction RPC; kaspad returns the txId. |
| 6 | Position record | Server appends best-effort metadata. The on-chain transaction is canonical — if the server crashes, the bet still stands. |
Market state machine
A market moves through five states: Created when the cron compiles its BetLock artifacts; Open once published and accepting bets; Closed the moment its closesAt passes; Settling when the next cron tick computes the outcome and broadcasts payout; Resolved once payout confirms. After 24 hours, markets are pruned to an archive.
Why Kaspa.
Building a prediction market on Ethereum-family chains forces compromises. Block times too slow to settle 5-minute windows. Gas that eats any bet under $10. MEV bots front-running high-information resolutions. The workaround — moving to L2s — introduces a new trust problem: the sequencer, the bridge, the upgrade authority. The cure is worse than the disease for a protocol that's supposed to be trust-minimized. Kaspa solves the underlying problem instead of layering trust on top of it.
One-second finality
Kaspa's GhostDAG protocol confirms in roughly 1 second — actual confirmation, not optimistic finality with a challenge window. A bet placed 30 seconds before expiry needs to be on chain before the resolver runs. Ethereum's 12-second blocks + reorg risk make that impossible to guarantee. Kaspa makes it routine.
No MEV by design
Most chains have a global mempool anyone can observe; bots see your transaction and front-run it. For prediction markets this is catastrophic. Kaspa's parallel-block architecture means there's no canonical sequence to front-run — transactions land in independent blocks the DAG merges deterministically.
Native covenant scripting (Silverscript)
KOM doesn't run on a VM bolted on top of Kaspa. Silverscript compiles to script bytecode that runs as part of transaction validation. No Solidity, no EVM, no rollup. The same trust model as Bitcoin's UTXO system, extended just enough to enforce per-market covenant rules.
No bridge, no wrapper, no L2
Every other prediction-market protocol touching Kaspa today does so through a bridge or wrapped token. Bridges have lost more value than any other vector in crypto. KOM uses native KAS directly — the KAS in the BetLock pool is the KAS that pays winners. No custodian between you and your stake.
A blockDAG built for throughput
Kaspa processes blocks in parallel rather than sequentially. Settlement is bursty — when a popular market closes, hundreds of ShareToken claims may land in the same window. On a sequential chain that spikes fees. On Kaspa's DAG it doesn't.
You can build a prediction market on any chain. You can only build this protocol — sub-minute markets, native UTXO custody, no bridges, no L2 — on Kaspa. That's the bet.
Roadmap.
KOM is live on Kaspa testnet-12 today, running the full bet-and-settle loop end-to-end. The path to mainnet has four checkpoints. Each one is gated on real evidence, not a calendar.
Prove the loop
Auto-rolling catalog live. Bet flow fully on chain. Resolver on a 60-second cron. Frontend in active polish — Polymarket-grade card density, real-time charts, portfolio rebuild. Goal: zero unrecoverable bugs across 1,000 simulated bets before locking the contract.
Harden and verify
External audit of the Silverscript covenants by a Kaspa-native security firm. Migrate position metadata from JSON to a real database. Remove all developer-mode forensic logging. Sign-off on the oracle architecture and dispute path.
Real KAS, real markets
Deploy to Kaspa mainnet. Initial categories: crypto (KAS, BTC, ETH), then weather, then sports as oracle infrastructure matures. Partnership with at least one Kaspa-native price oracle. Public trading API ships alongside launch — programmatic bet placement and position management, so bots, market makers, and quant traders can participate without the frontend.
Beyond binary
Multi-asset markets (settle in KAS, track non-crypto underliers). Scalar markets beyond binary YES/NO. Community-voted markets — token-holders propose and vote on which new markets the protocol lists, moving catalog curation from the team to the community. Secondary-market matching improvements. Open the protocol to third-party frontends — KOM becomes the settlement layer; UI becomes a commodity.
Questions.
Is KOM live?+
Yes — the full bet-and-settle loop runs on Kaspa testnet-12 today. Early access to the testnet app is available on request (hello@komarkets.io). Mainnet launch is planned for Q4 2026 after audit completion.
How is this different from Polymarket?+
Polymarket is a centralized matching engine settling on Polygon; users hold USDC IOUs that depend on Polygon's bridge and Polymarket's custody. KOM uses native Kaspa — no bridge, no wrapper, no custodian. The on-chain pool is the actual KAS that pays out. Polymarket runs hours-to-days windows; KOM runs 5-minute-to-1-hour windows.
How is this different from Kalshi?+
Kalshi is a CFTC-regulated platform settling in USD via traditional banking — a centralized exchange with custody and KYC. KOM is a permissionless protocol: anyone with a Kaspa wallet can bet, no account, no KYC at the protocol level.
What's an oracle in this design?+
The oracle is whoever holds the schnorr private key matching the oraclePubkey baked into each BetLock at compile time. For auto-rolling crypto markets, it's a server-side process reading Kraken's price feed and signing the resolution. For mainnet we plan a decentralized setup — likely a multi-sig of price providers with a dispute window before final settlement.
Can I lose more than I bet?+
No. The BetLock covenant accepts a single input from your wallet. Whatever you sign is the maximum you can lose. No leverage, no liquidation, no margin call. If your side loses, your stake goes to the winning side pro-rata.
What happens if Kaspa testnet resets?+
Testnet bets are not recoverable across resets — that's the nature of testnet. The protocol code, market designs, and your wallet are unaffected. On mainnet, resets do not happen by design.
Does KOM take a fee?+
The current testnet design takes no protocol fee. Mainnet fee structure will be published before launch; the design target is a small (1–2%) fee taken from the winning side's payout, enforced at the covenant level, not by an off-chain accounting layer.
What if the resolver doesn't run?+
The resolver is a cron — if it stops, no markets settle and KAS sits in the BetLock pools. The covenant allows the oracle to settle any time after closesAt, so a halt is recoverable: when the resolver returns, all pending markets settle. For mainnet we plan a fallback path via multi-sig. There is no scenario where KAS is stuck forever.
Is there an API for automated trading?+
A public trading API is planned to ship alongside mainnet launch in Q4 2026 — programmatic bet placement and position management, so bots, market makers, and quant traders can participate directly without the frontend. Because every bet is already a plain Kaspa transaction signed client-side, the API surface is a thin wrapper over the same flow the web app uses today.
Who decides which markets exist?+
Today the team curates the auto-rolling catalog. The plan for 2027 is community-voted markets: token-holders propose new markets and vote on which ones the protocol lists, moving catalog curation from the team to the community. The settlement layer stays the same — governance decides what to list, the covenants decide how it pays out.
Is the codebase open-source?+
The covenant code (Silverscript) and a reference frontend will open-source after the Q3 audit. The protocol-level docs and architecture are open immediately.
KOM is being built in the open.
If you're a Kaspa builder, a prediction-market researcher, or a trader who wants to test the testnet — we want to hear from you.
hello@komarkets.io →