Runes UTXO Management and Transfer Mechanics

The Runes protocol embeds fungible token logic directly into Bitcoin's native UTXO model, treating each unspent transaction output as a potential container for a rune balance. Unlike account-based token standards, Runes do not maintain a separate global state mapping addresses to balances. Instead, a rune balance is held within a UTXO, and the protocol's core transfer rule is simple: by default, all runes held in the inputs of a transaction are destroyed unless explicitly redistributed to the transaction's outputs. This design forces wallet developers to treat rune-bearing UTXOs with the same care as bitcoin value, as a naive transaction construction can inadvertently burn a user's entire rune position.

To override the default destruction behavior, the protocol introduces edicts, which are instructions encoded in an OP_RETURN output. An edict specifies a rune ID, an amount, and an output index, allowing precise allocation of runes to specific UTXOs. A single transaction can contain multiple edicts, enabling batched transfers, and can also include a POINTER field to designate a non-OP_RETURN output for protocol data. Any transaction that interacts with runes but fails to parse correctly—due to a malformed OP_RETURN payload, an invalid edict, or an attempt to transfer a rune that does not exist—is classified as a cenotaph. In a cenotaph event, the input runes are not transferred; they are destroyed, creating an irreversible loss for the user.

This UTXO-centric architecture creates significant operational complexity for exchanges, marketplaces, and wallet providers. They must implement UTXO selection algorithms that are rune-aware, ensuring that a rune-bearing UTXO is not accidentally spent as a fee or consolidated into a change output without an accompanying edict. Indexer operators must parse and validate the OP_RETURN data of every transaction to maintain an accurate off-chain ledger of rune allocations. For teams integrating Runes, Chainscore Labs can audit the full transaction construction pipeline—from UTXO selection and edict encoding to cenotaph prevention—to prevent catastrophic asset loss and ensure compatibility with the reference ord implementation.

The Runes protocol encodes fungible token balances directly into Bitcoin's Unspent Transaction Output (UTXO) set, making UTXO management the core operational concern for any wallet or service handling Runes. Unlike account-based token standards, a Rune balance does not live at an address but is held by a specific UTXO. When that UTXO is spent in a transaction, the Runes it carries are destroyed unless the transaction explicitly instructs the protocol on how to redistribute them. This design ties token safety directly to the robustness of a wallet's coin-selection and transaction-construction logic.

The default transfer behavior is a critical safety net: if a transaction contains no OP_RETURN output with valid Runes edicts, all Runes held by the transaction's inputs are allocated to the first non-OP_RETURN output. This default rule prevents accidental loss in simple single-recipient transfers but becomes a significant risk vector in multi-output transactions, such as batch payments or when spending to a marketplace contract. A wallet that inadvertently constructs a transaction with multiple outputs without explicit edicts will see all input Runes consolidated into the first output, potentially sending them to an unintended recipient or a non-Rune-aware contract.

For precise control, the protocol defines an OP_RETURN-based edict system. An edict specifies a Rune ID, an amount, and an output index, allowing a single transaction to perform complex, multi-asset, multi-recipient distributions atomically. The protocol enforces strict rules: edicts must be sorted by Rune ID, amounts are encoded in a 128-bit little-endian format, and any malformation triggers the cenotaph model, destroying all input Runes. This makes rigorous input validation in transaction construction non-negotiable. Wallet developers must implement edict generation that correctly handles integer division for leftover dust and ensures the sum of all edicts for a given Rune ID does not exceed the total input balance.

For exchanges, custodians, and marketplace operators, the operational impact is immediate. A standard consolidation transaction that sweeps many small deposits into a cold wallet can destroy all associated Runes if not constructed with explicit edicts. Integration teams must treat every Rune-bearing UTXO as a special asset that requires a distinct spending path. Chainscore Labs can audit a wallet's UTXO selection and Rune transfer logic to identify cenotaph triggers, validate edict construction against the reference implementation, and ensure that default allocation behavior is never unintentionally relied upon in multi-output flows.