OP_RETURN

An OP_RETURN output is a note pinned to a transaction. It carries bytes, usually a small amount of data, and no one can ever spend it.

The trick is in the first byte. 0x6a is the opcode OP_RETURN, which ends a script as failed. A locking script that starts with it can never be satisfied, so the output is provably dead from the moment it’s created. Nodes know that, and never bother remembering it.

Try it

Pick the OP_RETURN example and hover its middle output.

What does an OP_RETURN output look like?

Here is a real one, in a transaction from block 130,809:

What does it mean? Nobody has said. Twelve outputs with this “PRLU” tag appeared in 200 recent blocks, all from one large address, along with one tagged “PRLB” whose payload looks like a 20-byte Ethereum-style address padded with zeros. They may be bridge or custody messages; neither tag appears in Pearl’s own software. Pearl doesn’t care: to the protocol it’s 39 bytes nobody can spend.

What are the rules?

Size

1 byte or more

Type

Locking script

Format

6a ‖ anything

Pearl’s consensus rule is short:

func isNullDataScript(script []byte) bool {
	return len(script) >= 1 && script[0] == OP_RETURN
}

Anything after 0x6a is allowed: pushes, other opcodes, bytes that don’t even parse. Pearl’s own comment notes this is looser than Bitcoin Core, which requires the rest to be data pushes.

These were tested against Pearl’s own code: a bare 6a, an 81-byte push, a 1,000-byte push, 6a ac (OP_RETURN then OP_CHECKSIG) and a 1-PRL burn all pass both consensus and policy. Two OP_RETURN outputs in one transaction pass consensus but fail policy.

How is more data written?

The push opcode after 6a grows with the data, exactly as in any script:

Both of those larger examples pass Pearl’s consensus and relay checks. Since the data is never executed, the 520-byte limit on stack items doesn’t apply to it.

What does it cost?

Output bytes are base bytes, counted in full. The PRLU output is 8 (amount) + 1 (length) + 39 (script) = 48 bytes, so it adds 48 vbytes to its transaction: 48 grains at the minimum relay fee, or about 2,400 at the 50 grains per vbyte most transactions paid that day.

Why do nodes forget them?

Because they can’t be spent. Every other output joins the UTXO set and stays until someone spends it, which may be never. An OP_RETURN output is skipped when the set is updated, so data stored this way costs nodes disk space in the block history, but not in the set of live coins that every node must keep fast.

Data still isn’t free. Output bytes are base bytes, counted in full toward vsize, so each byte of OP_RETURN data costs at least a grain at the minimum relay fee.

Where else does OP_RETURN appear?

• The witness commitment. Every coinbase in a block with witness data has an output 6a 24 aa21a9ed followed by 32 bytes, committing to all the block’s witnesses. In 200 recent blocks there were 192 of them. See coinbase.
• The genesis block. Pearl’s very first coinbase pays 0 grains to a bare 6a, its only output. There was no premine to spend.
• Merged mining. Some coinbases carry a tag, such as OP_RETURN "NAC*" plus 32 bytes from one merged-mining pool. Coinbases skip relay policy, so they can carry this alongside the witness commitment.
• Message signing. Oyster’s signmessage signs a small virtual transaction whose output is OP_RETURN <your message>. It never goes on chain.