@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/checkpoint/checkpoint_reexecution_tracker.ts

@@ -0,0 +1,167 @@
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+/**
+ * Outcome of attempting to re-execute a checkpoint proposal locally.
+ *
+ * - `valid`        — re-execution succeeded and the computed checkpoint matched the proposal.
+ * - `invalid`      — the proposal disagreed with the computed checkpoint, or violated a deterministic
+ *                    constraint (limits, signatures, etc).
+ * - `unvalidated`  — the local node could not complete validation for non-deterministic reasons
+ *                    (missing blocks/txs, timeouts, infra errors). Treated as proposer-fault for
+ *                    slashing but surfaced separately for telemetry.
+ */
+export type ReexecutionOutcome = 'valid' | 'invalid' | 'unvalidated';
+
+/**
+ * Tracks two pieces of per-slot state collected during proposal handling:
+ *
+ *  1. Whether each block proposal's transactions were successfully collected locally
+ *     (keyed by `slot` + `indexWithinCheckpoint`). Consumed by the data-withholding watcher.
+ *  2. The outcome of locally re-executing each checkpoint proposal (keyed by
+ *     `(checkpointNumber, archiveRoot)` and by `slot`). Consumed by the data-withholding
+ *     watcher (via `hasReexecuted`) and the sentinel (via `getOutcomeForSlot`).
+ *
+ * Both pieces of state live on the same per-slot `Entry`, so cleanup via `removeBefore`
+ * naturally drops everything for a pruned slot in one step.
+ */
+interface Entry {
+  // Set by recordOutcome — these may be undefined until the checkpoint proposal has been
+  // evaluated. recordTxsCollected may create an Entry before any of them are known.
+  checkpointNumber: CheckpointNumber | undefined;
+  archiveRoot: string | undefined;
+  outcome: ReexecutionOutcome | undefined;
+
+  slot: SlotNumber;
+
+  // Per block-proposal at this slot: indexWithinCheckpoint → true (collected) | false (failed to collect).
+  txsCollected: Map<number, boolean>;
+}
+
+export class CheckpointReexecutionTracker {
+  private readonly byCheckpoint = new Map<CheckpointNumber, Map<string, Entry>>();
+  private readonly bySlot = new Map<SlotNumber, Entry>();
+
+  /**
+   * Record the outcome of evaluating a checkpoint proposal.
+   * @param slot - Slot the proposal was for. Always required.
+   * @param archiveRoot - Archive root in the proposal.
+   * @param outcome - Outcome of evaluation.
+   * @param checkpointNumber - Checkpoint number, if known. Required for `valid` outcomes; optional
+   *   for `invalid`/`unvalidated` because some early rejections fire before blocks are loaded.
+   */
+  public recordOutcome(
+    slot: SlotNumber,
+    archiveRoot: Fr,
+    outcome: ReexecutionOutcome,
+    checkpointNumber?: CheckpointNumber,
+  ): void {
+    const archiveRootStr = archiveRoot.toString();
+
+    // Preserve any per-block txsCollected already accumulated for this slot.
+    const existing = this.bySlot.get(slot);
+    const entry: Entry = {
+      checkpointNumber,
+      archiveRoot: archiveRootStr,
+      slot,
+      outcome,
+      txsCollected: existing?.txsCollected ?? new Map(),
+    };
+
+    if (checkpointNumber !== undefined) {
+      let archives = this.byCheckpoint.get(checkpointNumber);
+      if (!archives) {
+        archives = new Map();
+        this.byCheckpoint.set(checkpointNumber, archives);
+      }
+      archives.set(archiveRootStr, entry);
+    }
+
+    this.bySlot.set(slot, entry);
+  }
+
+  /**
+   * Record whether the local node successfully collected the transactions for a block proposal.
+   * Called from the validator's proposal handler immediately after tx collection completes
+   * (regardless of whether re-execution will subsequently succeed). The data-withholding
+   * watcher consults these records as an authoritative signal: tx availability now is too
+   * weak (txs may have been evicted from the mempool by the time the watcher runs), but a
+   * record that the txs *were* available at proposal time still vouches for the proposer.
+   *
+   * @param slot - Slot the block proposal was for.
+   * @param indexWithinCheckpoint - Index of the block within its enclosing checkpoint.
+   * @param collected - True if every tx in the proposal was collected locally before deadline.
+   */
+  public recordTxsCollected(slot: SlotNumber, indexWithinCheckpoint: number, collected: boolean): void {
+    let entry = this.bySlot.get(slot);
+    if (!entry) {
+      entry = {
+        checkpointNumber: undefined,
+        archiveRoot: undefined,
+        slot,
+        outcome: undefined,
+        txsCollected: new Map(),
+      };
+      this.bySlot.set(slot, entry);
+    }
+    entry.txsCollected.set(indexWithinCheckpoint, collected);
+  }
+
+  /**
+   * Returns true if the given (checkpoint number, archive root) has been successfully
+   * re-executed locally (outcome `valid`).
+   */
+  public hasReexecuted(checkpointNumber: CheckpointNumber, archiveRoot: Fr): boolean {
+    return this.byCheckpoint.get(checkpointNumber)?.get(archiveRoot.toString())?.outcome === 'valid';
+  }
+
+  /** Returns the recorded outcome for a given slot, or undefined if no proposal was evaluated. */
+  public getOutcomeForSlot(slot: SlotNumber): ReexecutionOutcome | undefined {
+    return this.bySlot.get(slot)?.outcome;
+  }
+
+  /**
+   * Returns the recorded tx-collection result for a block proposal at the given slot and
+   * `indexWithinCheckpoint`, or `undefined` if no record exists.
+   *
+   * Three-valued by design:
+   *   - `true`      — we collected every tx for this block proposal before the deadline.
+   *   - `false`     — we tried and failed (missing txs at the deadline).
+   *   - `undefined` — no record (e.g. we never saw the block proposal). Callers should fall
+   *                   back to a current-state check (e.g. mempool probe) for this case.
+   */
+  public getTxsCollectedRecord(slot: SlotNumber, indexWithinCheckpoint: number): boolean | undefined {
+    return this.bySlot.get(slot)?.txsCollected.get(indexWithinCheckpoint);
+  }
+
+  /** Drops entries for checkpoints with `number < checkpointNumber`. */
+  public removeBefore(checkpointNumber: CheckpointNumber): void {
+    // Track the highest slot among checkpoints we're pruning. Once we know it, any slot
+    // strictly below that watermark is older than the most recently pruned checkpoint and
+    // can be dropped from `bySlot` too — including slot-only entries (no checkpoint number)
+    // which would otherwise leak, because removing by checkpoint number can't reach them.
+    let maxRemovedSlot: SlotNumber | undefined;
+    for (const [n, archives] of this.byCheckpoint) {
+      if (n < checkpointNumber) {
+        for (const entry of archives.values()) {
+          // Only drop the slot index if it still points at the entry we're removing.
+          if (this.bySlot.get(entry.slot) === entry) {
+            this.bySlot.delete(entry.slot);
+          }
+          if (maxRemovedSlot === undefined || entry.slot > maxRemovedSlot) {
+            maxRemovedSlot = entry.slot;
+          }
+        }
+        this.byCheckpoint.delete(n);
+      }
+    }
+
+    if (maxRemovedSlot !== undefined) {
+      for (const slot of [...this.bySlot.keys()]) {
+        if (slot < maxRemovedSlot) {
+          this.bySlot.delete(slot);
+        }
+      }
+    }
+  }
+}

package/src/checkpoint/digest.ts

@@ -0,0 +1,28 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { type CoordinationSignatureContext, getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+
+/**
+ * Computes the EIP-712 payload digest for a checkpoint proposal — the digest validators sign
+ * and the L1 contract verifies during `propose()`. Mirrors `ProposeLib.digest(ProposePayload)` on L1.
+ *
+ * The result is the same `bytes32` that gets stored in `tempCheckpointLogs[checkpointNumber].payloadDigest`,
+ * so this helper is also reused when constructing simulation state overrides for pipelined proposals.
+ */
+export function computeCheckpointPayloadDigest(args: {
+  header: CheckpointHeader;
+  archiveRoot: Fr;
+  feeAssetPriceModifier: bigint;
+  signatureContext: CoordinationSignatureContext;
+}): Buffer32 {
+  const consensusPayload = new ConsensusPayload(
+    args.header,
+    args.archiveRoot,
+    args.feeAssetPriceModifier,
+    args.signatureContext,
+  );
+  return getHashedSignaturePayloadTypedData(consensusPayload);
+}

package/src/checkpoint/index.ts

@@ -1 +1,9 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';
+export * from './checkpoint_data.js';
+export * from './checkpoint_info.js';
+export * from './checkpoint_reexecution_tracker.js';
+export * from './digest.js';
+export * from './previous_checkpoint_out_hashes.js';
+export * from './published_checkpoint.js';
+export * from './simulation_overrides.js';
+export * from './validate.js';

package/src/checkpoint/previous_checkpoint_out_hashes.ts

@@ -0,0 +1,61 @@
+import { CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { Logger } from '@aztec/foundation/log';
+
+import type { L2BlockSource } from '../block/l2_block_source.js';
+import { type L1RollupConstants, getEpochAtSlot } from '../epoch-helpers/index.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+
+/**
+ * Returns the out hashes (in epoch order) of all checkpoints in `epoch` that precede
+ * `checkpointNumber`, used to compute the `epochOutHash` baked into that checkpoint's header.
+ *
+ * Under proposer pipelining the parent checkpoint may not be confirmed on L1 by the time the
+ * builder runs, so the on-chain archiver query (`getCheckpointsData`) is missing it and the
+ * resulting `epochOutHash` would diverge from what other validators (and L1) compute after the
+ * parent lands. To avoid that, the parent's `checkpointOutHash` is spliced in from the locally
+ * known proposed checkpoint when:
+ *   - pipelining is enabled,
+ *   - the archiver lookup is genuinely short (its last entry is not already cp `N-1`),
+ *   - and the proposed cp `N-1` is in the same target epoch (otherwise we're at an epoch boundary
+ *     and the previous-epoch cps must be excluded).
+ *
+ * Callers may either pass the already-loaded `proposedCheckpointData` (the proposer has it on
+ * hand) or leave it undefined, in which case it's fetched via `getProposedCheckpointData`.
+ */
+export async function getPreviousCheckpointOutHashes(input: {
+  blockSource: Pick<L2BlockSource, 'getCheckpointsData' | 'getProposedCheckpointData'>;
+  epoch: EpochNumber;
+  checkpointNumber: CheckpointNumber;
+  l1Constants: Pick<L1RollupConstants, 'epochDuration'>;
+  pipeliningEnabled: boolean;
+  proposedCheckpointData?: ProposedCheckpointData;
+  log?: Logger;
+}): Promise<Fr[]> {
+  const { blockSource, epoch, checkpointNumber, l1Constants, pipeliningEnabled, log } = input;
+
+  const checkpointed = (await blockSource.getCheckpointsData({ epoch }))
+    .filter(c => c.checkpointNumber < checkpointNumber)
+    .sort((a, b) => a.checkpointNumber - b.checkpointNumber);
+
+  if (!pipeliningEnabled || checkpointNumber === 0) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  const parentCheckpoint = CheckpointNumber(checkpointNumber - 1);
+  if (checkpointed.at(-1)?.checkpointNumber === parentCheckpoint) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  const proposedParent =
+    input.proposedCheckpointData ?? (await blockSource.getProposedCheckpointData({ number: parentCheckpoint }));
+  if (!proposedParent || proposedParent.checkpointNumber !== parentCheckpoint) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+  if (getEpochAtSlot(proposedParent.header.slotNumber, l1Constants) !== epoch) {
+    return checkpointed.map(c => c.checkpointOutHash);
+  }
+
+  log?.debug(`Splicing pipelined parent cp ${parentCheckpoint} outHash for cp ${checkpointNumber}`);
+  return [...checkpointed.map(c => c.checkpointOutHash), proposedParent.checkpointOutHash];
+}

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,108 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto/random';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
+import { Checkpoint } from './checkpoint.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        blockNumber: schemas.BigInt,
+        timestamp: schemas.BigInt,
+        blockHash: z.string(),
+      })
+      .transform(obj => L1PublishedData.fromFields(obj));
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): L1PublishedData {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    return new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash);
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.blockNumber, this.blockHash, this.timestamp);
+  }
+}
+
+export class PublishedCheckpoint {
+  constructor(
+    /** The checkpoint itself. */
+    public checkpoint: Checkpoint,
+    /** Info on when this checkpoint was published on L1. */
+    public l1: L1PublishedData,
+    /** The attestations for the last block in the checkpoint. */
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        checkpoint: Checkpoint.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedCheckpoint.from(obj));
+  }
+
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpoint = reader.readObject(Checkpoint);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation, MAX_COMMITTEE_SIZE);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpoint,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/checkpoint/simulation_overrides.ts

@@ -0,0 +1,171 @@
+import {
+  type FeeHeader,
+  RollupContract,
+  SimulationOverridesBuilder,
+  type SimulationOverridesPlan,
+} from '@aztec/ethereum/contracts';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+
+import type { CoordinationSignatureContext } from '../p2p/signature_utils.js';
+import type { ProposedCheckpointData } from './checkpoint_data.js';
+import { computeCheckpointPayloadDigest } from './digest.js';
+
+type CheckpointSimulationOverridesPlanInput = {
+  /** Target rollup contract. */
+  rollup: RollupContract;
+  /** Checkpoint number to be proposed. */
+  checkpointNumber: CheckpointNumber;
+  /** Logger instance. */
+  log: Logger;
+  /**
+   * The proposed parent checkpoint when pipelining. Its `checkpointNumber` must equal
+   * `checkpointNumber - 1`; the helper enforces this. Mutually exclusive with
+   * `invalidateToPendingCheckpointNumber`.
+   */
+  proposedCheckpointData?: ProposedCheckpointData;
+  /**
+   * The pending checkpoint number we'll end up at after invalidation lands. Mutually exclusive
+   * with `proposedCheckpointData`.
+   */
+  invalidateToPendingCheckpointNumber?: CheckpointNumber;
+  /**
+   * The real on-chain pending checkpoint number (typically `syncedTo.checkpointedCheckpointNumber`).
+   * Used as the snapshot we pin both `pending` and `proven` to avoid prunes in simulation.
+   */
+  checkpointedCheckpointNumber: CheckpointNumber;
+  /**
+   * Chain-level consensus signature context. Used to recompute the parent's `payloadDigest` for the
+   * pipelined simulation override so it matches what `propose` will write into `tempCheckpointLogs[parent]`
+   * once the parent lands.
+   */
+  signatureContext: CoordinationSignatureContext;
+};
+
+/**
+ * Builds the SimulationOverridesPlan describing the simulated L1 rollup state for a checkpoint's
+ * enqueue-time simulations: `canProposeAt` (in Sequencer.doWork) and the propose-related sims
+ * (validateBlockHeader, simulateProposeTx). The plan reflects "as if our pipelined parent
+ * checkpoint has landed and any required invalidation has executed" — the gap that needs to be
+ * bridged at enqueue time.
+ *
+ * Pipelining (`proposedCheckpointData`) and invalidation (`invalidateToPendingCheckpointNumber`)
+ * are mutually exclusive; passing both throws.
+ */
+export async function buildCheckpointSimulationOverridesPlan(
+  input: CheckpointSimulationOverridesPlanInput,
+): Promise<SimulationOverridesPlan | undefined> {
+  if (input.proposedCheckpointData && input.invalidateToPendingCheckpointNumber !== undefined) {
+    throw new Error(
+      'Error in buildCheckpointSimulationOverridesPlan: proposedCheckpointData and invalidateToPendingCheckpointNumber are mutually exclusive',
+    );
+  }
+
+  const builder = new SimulationOverridesBuilder();
+  const pendingCheckpointNumber = derivePendingCheckpointNumber(input);
+
+  // Override the latest checkpoint number when invalidating or pipelining, so our checkpoint
+  // follows from it. We also override the proven chain tip so we dont need to worry about
+  // prunes kicking in that would break out simulation if there's a prune pending. We always
+  // assume that a proof will land in time. If we don't have a pending checkpoint number to force,
+  // we still set both tips to the current checkpoint number to avoid the prune trigger.
+  const overridenChainTip = pendingCheckpointNumber ?? input.checkpointedCheckpointNumber;
+  builder.withChainTips({ pending: overridenChainTip, proven: overridenChainTip });
+
+  if (input.proposedCheckpointData) {
+    const { header, archive, checkpointOutHash, feeAssetPriceModifier } = input.proposedCheckpointData;
+    builder.withPendingArchive(archive.root);
+    // Override every locally-derivable `tempCheckpointLogs[parent]` field that L1 will eventually
+    // write. `slotNumber` is load-bearing for `STFLib.canPruneAtTime`: without it the cell reads
+    // slotNumber 0, the contract treats the pending tip as belonging to an expired epoch, and
+    // `getEffectivePendingCheckpointNumber` silently collapses pending back to proven — producing
+    // a spurious `Rollup__InvalidArchive` against the on-chain genesis archive. The other fields
+    // (headerHash, outHash, payloadDigest) are not strictly load-bearing for `canProposeAt` /
+    // `validateBlockHeader`, but mirroring the full cell keeps the simulation byte-faithful with
+    // what the actual `propose()` send will observe, which is a defense against future reads
+    // taking dependencies on them.
+    builder.withPendingTempCheckpointLogFields({
+      headerHash: header.hash(),
+      outHash: checkpointOutHash,
+      slotNumber: header.slotNumber,
+      payloadDigest: computeCheckpointPayloadDigest({
+        header,
+        archiveRoot: archive.root,
+        feeAssetPriceModifier,
+        signatureContext: input.signatureContext,
+      }),
+    });
+
+    const feeHeader = await computePipelinedParentFeeHeader({
+      checkpointNumber: input.checkpointNumber,
+      proposedCheckpointData: input.proposedCheckpointData,
+      rollup: input.rollup,
+      log: input.log,
+    });
+    if (feeHeader) {
+      builder.withPendingFeeHeader(feeHeader);
+    }
+  }
+
+  return builder.build();
+}
+
+function derivePendingCheckpointNumber(input: CheckpointSimulationOverridesPlanInput): CheckpointNumber | undefined {
+  if (input.invalidateToPendingCheckpointNumber !== undefined) {
+    return input.invalidateToPendingCheckpointNumber;
+  }
+  if (!input.proposedCheckpointData) {
+    return undefined;
+  }
+  if (input.checkpointNumber < 1) {
+    throw new Error(`Cannot build simulation override for checkpoint ${input.checkpointNumber}: no parent exists`);
+  }
+  const expectedParent = CheckpointNumber(input.checkpointNumber - 1);
+  if (input.proposedCheckpointData.checkpointNumber !== expectedParent) {
+    throw new Error(
+      `Cannot build simulation override for checkpoint ${input.checkpointNumber}: proposedCheckpointData.checkpointNumber (${input.proposedCheckpointData.checkpointNumber}) does not match expected parent ${expectedParent}`,
+    );
+  }
+  return expectedParent;
+}
+
+type PipelinedParentFeeHeaderInput = {
+  checkpointNumber: CheckpointNumber;
+  proposedCheckpointData: ProposedCheckpointData;
+  rollup: RollupContract;
+  log: Logger;
+};
+
+/**
+ * Derives the pending parent fee header used during pipelined proposal simulation. Returns
+ * `undefined` only when no grandparent exists (i.e. the proposed parent is the genesis
+ * checkpoint); all other failure modes (missing grandparent state, missing fee header, RPC
+ * errors) throw so callers don't silently desync the fee-header override.
+ */
+export async function computePipelinedParentFeeHeader(
+  input: PipelinedParentFeeHeaderInput,
+): Promise<FeeHeader | undefined> {
+  if (input.checkpointNumber < 2) {
+    return undefined;
+  }
+
+  const grandparentCheckpointNumber = CheckpointNumber(input.checkpointNumber - 2);
+
+  const [grandparentCheckpoint, manaTarget] = await Promise.all([
+    input.rollup.getCheckpoint(grandparentCheckpointNumber),
+    input.rollup.getManaTarget(),
+  ]);
+
+  if (!grandparentCheckpoint?.feeHeader) {
+    throw new Error(
+      `Grandparent checkpoint or feeHeader missing for checkpoint ${grandparentCheckpointNumber.toString()}`,
+    );
+  }
+
+  return RollupContract.computeChildFeeHeader(
+    grandparentCheckpoint.feeHeader,
+    input.proposedCheckpointData.totalManaUsed,
+    input.proposedCheckpointData.feeAssetPriceModifier,
+    manaTarget,
+  );
+}