executor

func BlockExecutionRoot ¶ added in v1.30.10

func BlockExecutionRoot(
	parentExecutionRoot ids.ID,
	blkTxs []*txs.Tx,
	postState state.Chain,
	height uint64,
) (ids.ID, error)

BlockExecutionRoot resolves the canonical leaf projection for a block and returns the execution_root the block must carry at [height]. It is the bridge from a stateless block to the pure xvm root computation: the builder calls it to stamp the root and the executor calls it to verify the stamped root, so the produced root and the verified root are derived by exactly one code path and can never disagree.

[parentExecutionRoot] is the parent block's MerkleRoot (the empty root for a genesis or pre-activation parent). [postState] is the post-block state (the applied state diff) the UTXO/asset families are projected from. The leaf projection is the canonical, deterministic, pure-function-of-the-block image of the post-block state the root commits to. The tx family is fully realized from the block's transactions (TxID = tx.ID(), every tx folded in block order, status = accepted); it is identical on the builder and the verifier because both observe the same ordered tx set. The UTXO family is enumerated from the post-block occupied UTXO set and projected by postBlockUTXOLeaves; the asset family is empty (see postBlockAssetLeaves for why xvm's UTXO-only executor state has no enumerable asset arena to project).

It returns an error if the post-block state cannot be enumerated or an output carries an owner model with no canonical owner_root yet — a wrong root must never be stamped or accepted silently.

func OwnerRoot ¶ added in v1.30.10

func OwnerRoot(o owners) [32]byte

OwnerRoot is the CANONICAL Go definition of the execution_root UTXO leaf's owner_root field. It is the authority the GPU state-snapshot producer MUST match (the GPU/CPU kernels treat owner_root as a host-supplied input — xvm_gpu_layout.hpp documents its intent as "keccak over sorted owner address set + threshold" but does not derive it; this is where that derivation is pinned).

owner_root = keccak256(

threshold_u32_le ‖ key_count_u32_le ‖ key[0] ‖ key[1] ‖ … ‖ key[k-1] )

where:

• threshold is the output's N-of-M spend threshold (binds the M-of-N policy, per the layout's "+ threshold");
• key_count is the number of owner keys, little-endian u32 — a length prefix so two owner sets that differ only by a key-set/threshold framing can never collide (no ambiguous concatenation);
• each key is an owner key in canonical ascending byte order: for an address-keyed output the 20-byte secp256k1 address; for a bls attestation output the committee public key. The order is the same sorted-and-unique order the output's own Verify enforces, so the preimage is deterministic and independent of the order keys happened to be listed in.

The keccak256 is Ethereum Keccak-256 (the same hash xvmroot/the GPU use for every leaf preimage), keeping owner_root in the one hash family the whole execution_root is built from. Integers are little-endian to match the kernel's absorb_u32.

Locktime is NOT folded into owner_root: the UTXOLeaf binds Locktime in its own dedicated field (matching the GPU UTXO struct, which carries locktime and owner_root separately), so binding it here too would be redundant. Threshold is bound in BOTH owner_root and the leaf's Threshold field, exactly as the GPU struct carries threshold both inside the host-computed owner_root and as a standalone field.