A Bitcoin transaction can confirm while its Runes tokens go to an unintended output or are burned. Follow one transfer below, then change one instruction at a time to see exactly where the token balance ends up.
Reading path: For the vocabulary, start with the Ordinals, inscriptions, BRC-20 and Runes concept guide. This lesson focuses on output accounting and burn conditions. It uses invented balances and decoded instructions, not a transaction you should broadcast.
Two accounting layers: satoshis and rune units
Bitcoin validates the underlying transaction. Runes-aware software interprets additional rules to associate token balances with its unspent outputs. Running your own compatible indexer is possible; ordinary Bitcoin validation does not replace that interpretation.
A runestone is the protocol message. Etching defines a rune; minting creates units under its terms; an edict allocates a rune amount to an output. A pointer chooses where units left after the edicts go. An output can carry more than one rune, so an address or logo alone is insufficient: record the rune ID, transaction ID and output index. Bitcoin fees are paid in satoshis, not by subtracting rune units from the token balance.
The Handbook's protocol guide explicitly says the ord implementation is normative. This explanation helps you read a result; it is not a replacement for compatible wallet software or the implementation.
Follow the output ledger
Invented setup: one input contains 12,000 satoshis and 1,000 atomic units of a single existing rune, called R here. R is an explanatory label, not a real ticker or rune ID. Assume divisibility zero, no etching, no mint and no other rune. The transaction has exactly three outputs, indexed from zero:
| Output | Bitcoin value and destination | Rune units after processing |
|---|---|---|
| 0 | 0 sats; OP_RETURN carrying the runestone | 0 |
| 1 | 3,000 sats; recipient | 250 |
| 2 | 8,000 sats; sender's change | 750 |
The decoded instructions are edict: R, amount 250, output 1; pointer: 2. Start with 1,000 unallocated units. The edict allocates 250 to output 1, leaving 750. Pointer 2 sends that remainder to output 2. No units are assigned to output 0 just because it contains the message.
Reconcile both ledgers: 12,000 - 3,000 - 8,000 = 1,000 sats fee; separately, 250 + 750 + 0 burned = 1,000 rune units. The fee is an assumed arithmetic result, not a current fee recommendation. Neither the BTC values nor a wallet's “change” label determines the rune destination by itself.
Change one instruction and trace the result
Keep the input balances and output order above. Treat each row independently; all unmentioned fields are assumed valid. The no-message row has no recognized runestone; the final row has a malformed one. Each row starts fresh from the original 1,000 units.
| Variant | Result | Why it differs |
|---|---|---|
| 250 to output 1; pointer 2 | 250 / 750 / 0 | The intended allocation. |
| 250 to output 1; omit pointer | 1,000 / 0 / 0 | The remaining 750 goes to the first non-OP_RETURN output: output 1, not the output labelled change. |
| No recognized runestone | 1,000 / 0 / 0 | Replace output 0's message with ordinary OP_RETURN data that does not match the runestone marker. Input runes default to output 1. Absence is not a cenotaph. |
| 250 to output 1; pointer 0 | 250 / 0 / 750 | The remainder is assigned to an OP_RETURN output and burned. A valid runestone can burn tokens. |
| 250 to output 1; pointer 3 | 0 / 0 / 1,000 | There is no output 3. An out-of-range pointer makes a cenotaph; the edict is not partially honored. |
In every row, recipient + change + burned equals 1,000. These are alternative token interpretations of deliberately different messages, not stages of one transaction. “Confirmed” therefore answers a different question from “my recipient received 250.” If these were real records, retain the decoded message and output list that support the claimed balance.
The boundary that is easy to misread
For a transaction with three outputs, the ordinary indices are 0, 1, 2. A pointer of 3 is invalid. However, an edict output of 3 has a special distribution meaning; only an edict output greater than 3 is out of range. The two fields do not share the same boundary rule.
As a separate variant of our setup, a single edict R, amount 0, output 3 divides the 1,000 unallocated units across the two non-OP_RETURN outputs: 500 to output 1 and 500 to output 2. Amount zero here does not mean “transfer nothing.” This is a decoded-rule example; it deliberately omits byte encoding and transaction construction.
A cenotaph is a malformed recognized message. All input runes are burned, not just units mentioned by its edicts. Certain parseable mint or etching fields can have further consequences: a counted mint can consume mint capacity while its units burn, and an accepted etching can have zero supply and no mintability. Do not diagnose those cases from a generic “failed” badge; the parser's result and relevant mint/etching conditions matter.
Check a transaction report before trusting its balance
- Fix the identity: record the network, transaction ID, confirmation context, rune ID and display divisibility. Separate atomic units from the displayed decimal amount.
- Inspect inputs: identify every token-bearing UTXO and all rune balances it contributes. A wallet total can hide an unrelated token spent in the same transaction.
- Read outputs in order: record their zero-based indices, scripts and satoshi values. Do not assume “change” is the token remainder destination.
- Read the interpretation: distinguish no runestone, a valid runestone and a cenotaph. Reconcile edicts, pointer/default allocation and burns against the input total, adding any valid mint or premine separately.
- Resolve disagreement: record the wallet/indexer version and indexed block height. Compare the same transaction and chain state before assuming that a missing display means loss. A display repair does not reverse an actual protocol burn.
What the ledger cannot prove: correct allocation says nothing about a buyer's willingness to purchase the token, marketplace reliability or a permanent rise in miner income. Runes support also does not establish Lightning compatibility; that needs evidence for the specific implementation. The Bitcoin transaction and UTXO guide provides the underlying payment model.
Sources and review scope
- Ordinal Theory Handbook: Runes overview — terminology, output balances and burns.
- Handbook: protocol description and implementation authority — pointer, edict boundary and cenotaph behavior.
- ord: rune_updater.rs — allocation order, no-message default, OP_RETURN and cenotaph burn handling.
- ord: runestone.rs — message parsing, pointer validation and parser tests.
Reviewed 13 November 2026 against the linked documentation and readable implementation branches. Branch links can change. The examples were checked for arithmetic and consistency with the inspected rules; they were not broadcast, executed with an ord node, or tested across wallets. This is a scoped explanation, not an audit of the protocol.
Revision history and scope
19 October 2026: Corrected the earlier no-indexer claim and distinguished Bitcoin settlement from token interpretation. Removed an unsupported expectation of near-term Lightning support.
24 October 2026: Added a reader-focused introduction and a revision-history section; the earlier factual review date was retained.
13 November 2026: Replaced the brief 250/750 illustration with output-indexed BTC and rune ledgers, alternative allocation/burn outcomes and the pointer-versus-edict boundary. Checked the related concept guide to keep this lesson's role distinct. Moved historical correction discussion out of the main lesson. Original title, URL and first publication date retained.
