# QBIT-20 — Protocol Specification v1

Status: experimental. No audit. This document is a convention, not a contract.
Chain: Qbit. Carrier: OP_RETURN. Balances: off-chain indexer only.

## 1. What QBIT-20 is

QBIT-20 is an inscription convention on Qbit. A JSON object is written to an
OP_RETURN output. An indexer reads those objects back in block order and
maintains balances. The chain stores text. It does not know ticks, supplies,
or balances.

This is not Ordinals. There is no Taproot, no commit / reveal envelope, no
sat binding, and no sat numbering on Qbit. Do not apply Bitcoin BRC-20
assumptions here.

## 2. Record format

- Encoding: UTF-8 JSON, written as the single data push of one OP_RETURN output.
- Field `p` must be exactly `"qbit-20"`. It is case-sensitive. `"QBIT-20"`,
  `"qrc-20"`, and `"brc-20"` are different protocols and are ignored.
- Field `tick` must be exactly 4 characters, uppercase letters A–Z or digits
  0–9. Example: `QORD`.
- Amount fields (`max`, `lim`, `amt`) are strings of decimal integers.
  No decimals, no signs, no separators, no leading zeros (except the
  string `"0"` itself).
- Field `dec` must be exactly `"8"`. A deploy with any other `dec` is
  not a valid deploy; the indexer ignores it.
- If a transaction carries more than one OP_RETURN output, the indexer
  reads the first one. The rest are ignored.
- Unknown fields are ignored. Malformed JSON is ignored. An invalid record
  never fails the transaction; the indexer simply skips it.

## 3. Operations

### deploy

```json
{"p": "qbit-20", "op": "deploy", "tick": "QORD", "max": "210000000", "lim": "2100", "dec": "8"}
```

- The first valid deploy for a tick, in block order, is canonical.
  Later deploys of the same tick are ignored.
- `max` is the total supply. `lim` is the amount of one mint.
  `dec` is `"8"`.
- A deploy does not mint anything. It only opens the tick.

### mint

```json
{"p": "qbit-20", "op": "mint", "tick": "QORD", "amt": "2100"}
```

- Valid only after the tick is deployed.
- `amt` must equal `lim`, except for the final remainder mint, where
  `amt` must equal `max` minus the amount already minted, and must be
  greater than zero.
- Minting stops when cumulative minted reaches `max`. Overshoot is ignored.
- The minted amount is credited to the `available` balance of the sender
  address (the first input address of the mint transaction, as read by
  the indexer).
- Minting opens at deploy height + 60 blocks (about 1 hour at ~60 s
  per block). Mints recorded before that height are ignored. (Changed
  2026-10-28: delay reduced from 360 blocks to 60 blocks.)

### transfer

```json
{"p": "qbit-20", "op": "transfer", "tick": "QORD", "amt": "2100"}
```

- One step. There is no inscribe-then-send two-step flow and no
  `transferable` state. Balances have a single column: `available`.
- The receiver is the first non-OP_RETURN output address of the same
  transaction. If there is no such output, the transfer is ignored.
- The sender is the first input address of the transaction, the same
  definition as for mint. The sender must hold at least `amt` in
  `available` at the time the indexer processes the block. Otherwise
  the transfer is ignored.
- On a valid transfer the indexer moves `amt` from the sender's
  `available` to the receiver's `available`.

## 4. Parameters — first token

| Item | Value |
|---|---|
| Protocol | `qbit-20` |
| Tick | `QORD` |
| Max supply | `210,000,000` |
| Per-mint limit (`lim`) | `2,100` |
| Decimals (`dec`) | `8` |
| Total mints | `100,000` (210,000,000 / 2,100) |
| Mint open | deploy height + 60 blocks (~1 hour) |

## 5. Anti-sweep rules (indexer-enforced)

These rules exist so one script cannot take the whole supply in minutes,
and so a small mint is still finishable. They are indexer rules, not
consensus rules. A transaction that breaks them is still valid on chain;
its record is ignored.

1. **One mint per address per block.** A second mint from the same
   address in the same block is ignored.
2. **100 mints per address, lifetime.** An address that has already
   had 100 valid mints cannot mint more of the same tick.
3. **20 valid mints per block, per tick.** The first 20 valid mints in
   a block count; the rest are ignored for that block. At 20 per block
   and ~60 s blocks, 100,000 mints take at least 5,000 blocks
   (~3.5 days) even under full demand.
4. **Delayed open.** Minting opens 60 blocks after deploy. No
   pre-announced start time is published on the page; the deploy
   height is the only clock.
5. **Fixed amount.** `amt` must equal `lim` (except the final
   remainder). Variable-amount mints are ignored. This removes the
   advantage of splitting one mint into many dust mints, and of
   stuffing a large amount into a single mint.
6. **One tick, one deploy.** First valid deploy wins. Re-deploys do
   not reset limits or supply.

Why these numbers: `lim` 2,100 with 100,000 mints keeps a single mint
small enough that no one finishes the supply alone, and large enough
that the supply can actually be minted. Per-address caps (1 per block,
100 lifetime) bound any single actor to at most 210,000 tokens
(0.1% of supply) without many addresses. The per-block cap bounds
the whole network to a multi-day mint, so latecomers still have a
window.

## 6. Indexer boundaries

- Order is block height, then transaction order inside the block.
  Mempool order does not count. Unconfirmed records are preview only.
- On a reorg, roll back to the common ancestor and replay.
- Only confirmed blocks are final for deploy / mint / transfer.
- The indexer must read full transactions, including OP_RETURN
  outputs. Address-only APIs are not enough.
- If two indexers disagree, there is no on-chain arbiter. Publish
  the indexer version and the rule set alongside any balance.
- A record that is valid JSON but breaks a rule in section 5 is
  ignored, not rejected. The transaction stays on chain.

## 7. What this does not promise

Experimental. No audit. No value, no market, no listing, no future
development is promised. A QBIT-20 record is text on a chain. Holding
a balance in an indexer is not holding a token on chain. Broadcast is
irreversible.

## 8. Reference

- Explorer: https://mempool.qbit.org
- Site: https://qbit20.vercel.app
- Whitepaper: https://qbit20.vercel.app/whitepaper
- Indexer API: https://qbit20-indexer.ethercemoji.workers.dev/