TYPE 0x0A01 · QABIO FAMILY

QABI_PRIME

Priming state transition for a QABIO-enabled UTXO. Reveals the next auth-chain preimage at a chosen depth, bumps committed_depth, and mutates the QABI_SPEND rung’s committed_root and committed_expiry to commit the UTXO into a specific upcoming batch. A participant-only operation: only the holder of the auth_seed can produce a valid preimage, so no coordinator signature is required at priming time. The new conditions tree is enforced via a covenant check against the output’s scriptPubKey.

QABIO Non-invertible

Ladder Diagram

Fields

Field	Data Type	Size	Side	Description
new_committed_root	HASH256	32 B	Witness	Batch root the participant is committing to. Substituted for `committed_root` inside the QABI_SPEND rung of the output conditions tree. Typically the Merkle root of the coordinator’s upcoming QABIBlock.
prime_depth	NUMERIC	1–4 B	Witness	Depth in the auth chain at which the preimage is revealed. Must strictly exceed the current `committed_depth` (monotonic progression) and be bounded by `QABI_AUTH_CHAIN_DEFAULT_LENGTH · 10`.
new_committed_expiry	NUMERIC	1–4 B	Witness	Max block height at which the subsequent QABI_SPEND may fire. Substituted for `committed_expiry` in the output tree.
prime_preimage	PREIMAGE	32 B	Witness	Preimage such that `SHA256` iterated `prime_depth` times yields the committed `auth_tip` from the QABI_SPEND rung. Only the `auth_seed` holder can produce this.

QABI_PRIME has no conditions-context fields. All four fields are witness-only. The evaluator reads the “current state” (auth_tip, committed_root/depth/expiry, owner_id) from the QABI_SPEND rung of the input conditions tree — there is no duplication.

Evaluation Logic

1.Witness must have exactly 4 fields: HASH256, NUMERIC, NUMERIC, PREIMAGE (correctly typed, correct sizes). Otherwise → ERROR

2.Locate exactly one QABI_SPEND block across all revealed rungs of input_conditions (via the MLSC proof + revealed mutation targets). If zero or more than one → UNSATISFIED

3.Read auth_tip and committed_depth from the located QABI_SPEND block’s conditions fields

4.Check prime_depth > committed_depth (monotonic progression). Otherwise → UNSATISFIED

5.Verify SHA256^prime_depth(prime_preimage) == auth_tip. Otherwise → UNSATISFIED

6.Covenant: rebuild the full input conditions tree with QABI_SPEND’s committed_root, committed_depth, and committed_expiry replaced by the witness values. Recompute the MLSC root. Extract the output UTXO’s conditions_root from tx.vout[coil.output_index].scriptPubKey. If they match → SATISFIED, otherwise → UNSATISFIED

Return Values

Condition	Result
Witness field count != 4 or wrong types/sizes	ERROR
prime_depth <= 0 or above safety bound	ERROR
No QABI_SPEND block found in input conditions	UNSATISFIED
Multiple QABI_SPEND blocks (ambiguous)	ERROR
prime_depth <= committed_depth	UNSATISFIED
SHA256^prime_depth(preimage) != auth_tip	UNSATISFIED
Output conditions_root != mutated-tree recomputed root	UNSATISFIED
All checks pass	SATISFIED

Worked Example

Alice primes her QABIO UTXO for a 100-party batch coordinated by a FALCON-512 signer

Alice’s UTXO conditions tree:

[SIG_escape, QABI_PRIME, QABI_SPEND(auth_tip=H^50(seed), committed_root=0, depth=0, expiry=0, owner_id=SHA256(alice_pk))]

Coordinator announces batch root R = 0xaa..aa, expiry block 1000

Alice builds a priming tx: input 0 = her UTXO, output 0 = new MLSC UTXO with QABI_SPEND(auth_tip, R, depth=10, expiry=1000, owner_id)

Alice signs the QABI_PRIME rung via signrungtx with witness {new_committed_root=R, prime_depth=10, new_committed_expiry=1000, prime_preimage=H^40(seed)}

Evaluator checks: SHA256^10(H^40(seed)) == H^50(seed) == auth_tip → check 4 passes

Evaluator rebuilds the conditions tree with mutated QABI_SPEND, recomputes MLSC root, matches the output UTXO’s root → SATISFIED

Alice broadcasts the priming tx. Her UTXO is now committed to batch R until block 1000. The coordinator can finalise the batch via QABI_SPEND at any block ≤ 1000.

Use Cases

Opt-in N-party batch commitment

Alice opts her UTXO into a specific upcoming coordinator batch by signing with her own private preimage. No cooperation with other participants is required at priming time — each participant primes independently. The covenant check ensures the primed UTXO is bound to the batch root until expiry.

Withdrawable escrow

Before priming, a UTXO can be spent via any other path in its conditions tree (e.g. a SIG escape rung). After priming, the QABI_SPEND path becomes valid for the coordinator. If the coordinator never fires, the SIG escape rung still works because QABI_PRIME only mutates the QABI_SPEND rung, not the escape rungs.

Auth-chain staging

A wallet can prime the same UTXO multiple times at progressively deeper auth-chain depths, each time committing to a different batch root. The monotonic depth rule prevents replay attacks and enforces forward-only state progression.

← P2TR_SCRIPT_LEGACY QABI_SPEND →