Function check_input_coherence

zisk/host/src/main.rs:734–762

Host-side coherence check for one input's shard proofs: every shard must carry the same `env_hash`, the ranges must tile `[0, total)` exactly, and failures are summed. Returns this input's failure count. (The agg guest can't yet parse leaf publics from the proof blob, so this is enforced here.)

(
  label: &str,
  publics: &[ShardPublics],
  total: u32,
)

/// `cover` (its `covered()` target addresses): `merkle_root_canonical` over the
/// addresses, exactly as the guest computes it. Used host-side to re-derive the
/// expected per-child subject *from the env* (not from the proof) so the final
/// aggregate's committed subject can be checked against the env it should cover.
fn subject_of_cover(cover: &[[u8; 32]]) -> ix_common::address::Address {
  use ix_common::address::Address;
  let leaves: Vec<Address> = cover
    .iter()
    .map(|b| Address::from_slice(b).expect("cover address"))
    .collect();
  ixon::merkle::merkle_root_canonical(&leaves)
    .unwrap_or_else(ixon::merkle::zero_address)
}

/// Partition `n` items into chunks of at most `arity` each, avoiding
/// any chunk of size exactly 1 (which would make agg-of-1 a no-op).
/// When the trailing remainder is 1, it's merged into the previous
/// chunk so the smallest chunk produced is size 2. Returns half-open
/// `(start, end)` index ranges.
fn tree_partition(n: usize, arity: usize) -> Vec<(usize, usize)> {
  if n <= arity {
    return vec![(0, n)];
  }
  let mut ranges: Vec<(usize, usize)> = Vec::new();
  let mut i = 0;
  while i + arity <= n {
    ranges.push((i, i + arity));
    i += arity;
  }
  let remainder = n - i;
  if remainder == 1 {
    // Merge the singleton into the previous chunk so the agg guest
    // never gets called with just one proof (which would be agg-of-1
    // pure overhead).