Outputs

An output is a coin: an amount, and a lock that says what it takes to spend it.

The amount is a whole number of grains, the smallest unit of PRL. The lock is a short locking script, usually the address of whoever is being paid, unwrapped into bytes. Once a transaction is in a block, each of its outputs sits in the ledger until a later transaction spends it.

Try it

Pick the payment and hover its two outputs.

What’s in an output?

Here is the first output of the real payment from block 130,825:

Amount

Size

8 bytes

Type

Signed integer (grains)

Format

Little-endian

Range

0 to 21 billion PRL

b0359f1100000000, read smallest byte first, is 0x119f35b0 = 295,646,640 grains, or 2.95646640 PRL. The second output’s 00c2eb0b00000000 is 200,000,000 grains: exactly 2 PRL.

The consensus cap on an amount (and on the total of a transaction’s outputs) is 21 billion PRL, ten times the real supply limit of 2.1 billion. It’s a sanity check, not the supply rule.

Locking script

Size

34 bytes for Taproot and P2MR

Type

Script

Format

Length-prefixed

22 says 34 bytes follow: 51 (OP_1, witness version 1), 20 (push 32 bytes) and the 32-byte tweaked key d7ab02c9…9416b2. That is the address prl1p674s9jt2…v9d5z4 in raw form; the address page shows the conversion.

How does a wallet write an output?

From an address and an amount, in four mechanical steps. Here is the payment’s second output, 2 PRL to prl1pvt5a5d5…euhn70:

1. Amount to grains

   2 PRL × 100,000,000 = 200,000,000 grains = 0x0bebc200.

2. Grains to 8 bytes, smallest first

   00 c2 eb 0b 00 00 00 00.

3. Address to locking script

   Decode the bech32m address: version 1, program 62e9da36…073b2b. Write 51 (OP_1), 20 (push 32), then the program.

4. Prefix the length

   34 bytes, so 22. The output is 8 + 1 + 34 = 43 bytes.

Every Taproot and P2MR output is exactly 43 bytes this way, which is what lets wallets predict a transaction’s size before signing it.

Which locking scripts are allowed?

Exactly three shapes. Pearl’s consensus code checks every output of every transaction, the coinbase included:

for i, txOut := range msgTx.TxOut {
	scriptClass := txscript.GetScriptClass(txOut.PkScript)
	if scriptClass != txscript.WitnessV1TaprootTy &&
		scriptClass != txscript.WitnessV2MerkleRootTy &&
		scriptClass != txscript.NullDataTy {
		str := fmt.Sprintf("transaction output %d has "+
			"unsupported script type %v", i, scriptClass)
		return ruleError(ErrScriptMalformed, str)
	}

Anything else makes the whole transaction invalid. These were all tested against Pearl’s own validation code:

What’s the smallest output?

As far as consensus goes, 0 grains. But nodes won’t relay a transaction that creates a Taproot or P2MR output below the dust limit, 333 grains, because such an output is worth so little that spending it would eat a large share of its value in fees.

The number comes from a formula: three times the cost, at the minimum relay fee of 1 grain per vbyte, of the output plus a typical input that would later spend it.

A 332-grain Taproot output is rejected by the mempool (“payment is dust: 332”); 333 passes. OP_RETURN outputs are exempt. Dust is policy: a miner could still put a 1-grain output in a block.

Which output is the change?

Nothing in the bytes says. Change is just another output, locked to an address the sender’s wallet controls.

Pearl’s wallet picks the change position at random, so it isn’t always last. In the payment above, the round 2 PRL output (second) is almost certainly the payment, and the first output, 2.95646640 PRL, the change. Observers use guesses like that; the protocol doesn’t care.

What happens to an output next?

• Taproot and P2MR outputs join the UTXO set under the name txid:index, here d919e02a…:0 and d919e02a…:1, until an input spends them.
• OP_RETURN outputs never enter the UTXO set. Nodes can forget them at once, which is why they’re the place for data.