@aztec/ethereum 0.0.1-commit.85d7d01 → 0.0.1-commit.8655d4a

package/src/client.ts

@@ -25,10 +25,35 @@ type Config = {
   l1ChainId: number;
   /** The polling interval viem uses in ms */
   viemPollingIntervalMS?: number;
+  /** Timeout for HTTP requests to the L1 RPC node in ms. */
+  l1HttpTimeoutMS?: number;
 };
 
 export type { Config as EthereumClientConfig };
 
+/** Creates a viem fallback HTTP transport for the given L1 RPC URLs. */
+export function makeL1HttpTransport(rpcUrls: string[], opts?: { timeout?: number }) {
+  return fallback(rpcUrls.map(url => http(url, { batch: false, timeout: opts?.timeout })));
+}
+
+/**
+ * Returns the individual RPC URLs underlying a viem public client that was constructed with a
+ * fallback HTTP transport (see {@link makeL1HttpTransport}). Returns an empty array if the
+ * transport shape is not recognized (e.g. mock clients in tests, or non-fallback transports).
+ */
+export function getRpcUrlsFromClient(client: ViemPublicClient): string[] {
+  const transport = client.transport as unknown as {
+    transports?: { value?: { url?: string } }[];
+    value?: { url?: string };
+    url?: string;
+  };
+  if (Array.isArray(transport?.transports)) {
+    return transport.transports.map(t => t?.value?.url).filter((url): url is string => typeof url === 'string');
+  }
+  const singleUrl = transport?.value?.url ?? transport?.url;
+  return typeof singleUrl === 'string' ? [singleUrl] : [];
+}
+
 // TODO: Use these methods to abstract the creation of viem clients.
 
 /** Returns a viem public client given the L1 config. */
@@ -36,7 +61,7 @@ export function getPublicClient(config: Config): ViemPublicClient {
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
   return createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(config.l1RpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
     pollingInterval: config.viemPollingIntervalMS,
   });
 }
@@ -77,6 +102,7 @@ export function createExtendedL1Client(
   chain: Chain = foundry,
   pollingIntervalMS?: number,
   addressIndex?: number,
+  opts?: { httpTimeoutMS?: number },
 ): ExtendedViemWalletClient {
   const hdAccount =
     typeof mnemonicOrPrivateKeyOrHdAccount === 'string'
@@ -88,7 +114,7 @@ export function createExtendedL1Client(
   const extendedClient = createWalletClient({
     account: hdAccount,
     chain,
-    transport: fallback(rpcUrls.map(url => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(rpcUrls, { timeout: opts?.httpTimeoutMS }),
     pollingInterval: pollingIntervalMS,
   }).extend(publicActions);
 

package/src/config.ts

@@ -2,7 +2,6 @@ import {
   type ConfigMappingsType,
   bigintConfigHelper,
   booleanConfigHelper,
-  enumConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -19,6 +18,8 @@ export type GenesisStateConfig = {
   testAccounts: boolean;
   /** Whether to populate the genesis state with initial fee juice for the sponsored FPC */
   sponsoredFPC: boolean;
+  /** Additional addresses to prefund with fee juice at genesis */
+  prefundAddresses: string[];
 };
 
 export type L1ContractsConfig = {
@@ -58,13 +59,13 @@ export type L1ContractsConfig = {
   slashingOffsetInRounds: number;
   /** How long slashing can be disabled for in seconds when vetoer disables it */
   slashingDisableDuration: number;
-  /** Type of slasher proposer */
-  slasherFlavor: 'empire' | 'tally' | 'none';
-  /** Minimum amount that can be slashed in tally slashing */
+  /** Whether to deploy a slasher proposer */
+  slasherEnabled: boolean;
+  /** Minimum amount that can be slashed */
   slashAmountSmall: bigint;
-  /** Medium amount to slash in tally slashing */
+  /** Medium amount to slash */
   slashAmountMedium: bigint;
-  /** Largest amount that can be slashed per round in tally slashing */
+  /** Largest amount that can be slashed per round */
   slashAmountLarge: bigint;
   /** Governance proposing quorum (defaults to roundSize/2 + 1) */
   governanceProposerQuorum?: number;
@@ -150,13 +151,10 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
       'How many slashing rounds back we slash (ie when slashing in round N, we slash for offenses committed during epochs of round N-offset)',
     ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_OFFSET_IN_ROUNDS),
   },
-  slasherFlavor: {
-    env: 'AZTEC_SLASHER_FLAVOR',
-    description: 'Type of slasher proposer (empire, tally, or none)',
-    ...enumConfigHelper(
-      ['empire', 'tally', 'none'] as const,
-      l1ContractsDefaultEnv.AZTEC_SLASHER_FLAVOR as 'empire' | 'tally' | 'none',
-    ),
+  slasherEnabled: {
+    env: 'AZTEC_SLASHER_ENABLED',
+    description: 'Whether to deploy a slasher proposer',
+    ...booleanConfigHelper(true),
   },
   slashAmountSmall: {
     env: 'AZTEC_SLASH_AMOUNT_SMALL',
@@ -259,6 +257,16 @@ export const genesisStateConfigMappings: ConfigMappingsType<GenesisStateConfig>
     description: 'Whether to populate the genesis state with initial fee juice for the sponsored FPC.',
     ...booleanConfigHelper(false),
   },
+  prefundAddresses: {
+    env: 'PREFUND_ADDRESSES',
+    description: 'Comma-separated list of Aztec addresses to prefund with fee juice at genesis (local network only).',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(a => a.trim())
+        .filter(a => a.length > 0),
+    defaultValue: [],
+  },
 };
 
 export function getL1ContractsConfigEnvVars(): L1ContractsConfig {

package/src/contracts/chain_state_override.ts

@@ -0,0 +1,200 @@
+import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Buffer32 } from '@aztec/foundation/buffer';
+import { merge } from '@aztec/foundation/collection';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { StateOverride } from 'viem';
+
+import { type FeeHeader, RollupContract } from './rollup.js';
+
+/**
+ * Override values for the pending checkpoint that the simulation should treat as already applied.
+ * Every field is optional at plan-building time so callers can populate them incrementally; whatever
+ * is present at translation time is forwarded to the partial `tempCheckpointLogs` helper so the
+ * load-bearing `slotNumber` can land even if other fields could not be derived locally.
+ */
+export type PendingCheckpointOverrideState = {
+  archive?: Fr;
+  feeHeader?: FeeHeader;
+  headerHash?: Fr;
+  outHash?: Fr;
+  payloadDigest?: Buffer32;
+  slotNumber?: SlotNumber;
+};
+
+export type ChainTipsOverride = {
+  pending?: CheckpointNumber;
+  proven?: CheckpointNumber;
+};
+
+/** Describes the simulated L1 rollup state that downstream calls should observe. */
+export type SimulationOverridesPlan = {
+  chainTipsOverride?: ChainTipsOverride;
+  pendingCheckpointState?: PendingCheckpointOverrideState;
+  disableBlobCheck?: boolean;
+};
+
+/** Builds a single-checkpoint simulation plan before it is translated into a viem state override. */
+export class SimulationOverridesBuilder {
+  private chainTipsOverride?: ChainTipsOverride;
+  private pendingCheckpointState?: PendingCheckpointOverrideState;
+  private disableBlobCheck = false;
+
+  /** Starts from an existing plan so callers can extend or specialize it. */
+  public static from(plan: SimulationOverridesPlan | undefined): SimulationOverridesBuilder {
+    return new SimulationOverridesBuilder().merge(plan);
+  }
+
+  /**
+   * Merges another plan into this builder. Later values win on a per-half basis for chain tips,
+   * but explicit `undefined` fields in the incoming plan are ignored so they cannot erase a
+   * previously-set value.
+   */
+  public merge(plan: SimulationOverridesPlan | undefined): this {
+    if (!plan) {
+      return this;
+    }
+
+    if (plan.chainTipsOverride) {
+      this.chainTipsOverride = merge(this.chainTipsOverride ?? {}, plan.chainTipsOverride);
+    }
+    if (plan.pendingCheckpointState) {
+      this.pendingCheckpointState = merge(this.pendingCheckpointState ?? {}, plan.pendingCheckpointState);
+    }
+    this.disableBlobCheck = this.disableBlobCheck || (plan.disableBlobCheck ?? false);
+
+    return this;
+  }
+
+  /**
+   * Sets the pending and/or proven checkpoint number overrides. Subsequent calls merge into the existing
+   * override on a per-half basis, so callers can set pending in one call and proven in another without
+   * clobbering each other.
+   */
+  public withChainTips(override: ChainTipsOverride): this {
+    this.chainTipsOverride = { ...(this.chainTipsOverride ?? {}), ...override };
+    return this;
+  }
+
+  /** Overrides the archive root for the configured pending checkpoint. */
+  public withPendingArchive(archive: Fr): this {
+    this.assertPendingCheckpointNumber();
+    this.pendingCheckpointState = { ...(this.pendingCheckpointState ?? {}), archive };
+    return this;
+  }
+
+  /** Overrides the fee header for the configured pending checkpoint. */
+  public withPendingFeeHeader(feeHeader: FeeHeader): this {
+    this.assertPendingCheckpointNumber();
+    this.pendingCheckpointState = { ...(this.pendingCheckpointState ?? {}), feeHeader };
+    return this;
+  }
+
+  /**
+   * Overrides one or more `tempCheckpointLogs` cell fields for the configured pending checkpoint.
+   * Fields are independent: any subset can be provided. The translator (`makeTempCheckpointLogOverride`)
+   * emits a stateDiff entry per field actually set, so unspecified fields stay at their on-chain
+   * values.
+   *
+   * `slotNumber` is load-bearing for `STFLib.canPruneAtTime`: when the simulation overrides `pending`
+   * to a checkpoint that has no on-chain `tempCheckpointLogs` entry yet, the missing slotNumber falls
+   * back to 0 and the contract treats the pending tip as belonging to epoch 0, triggering a phantom
+   * prune that silently undoes the `pending` override.
+   */
+  public withPendingTempCheckpointLogFields(fields: {
+    headerHash?: Fr;
+    outHash?: Fr;
+    payloadDigest?: Buffer32;
+    slotNumber?: SlotNumber;
+  }): this {
+    this.assertPendingCheckpointNumber();
+    this.pendingCheckpointState = { ...(this.pendingCheckpointState ?? {}), ...fields };
+    return this;
+  }
+
+  /** Disables blob checking for simulations that cannot provide DA inputs. */
+  public withoutBlobCheck(): this {
+    this.disableBlobCheck = true;
+    return this;
+  }
+
+  /** Builds the final plan, or `undefined` when no overrides were configured. */
+  public build(): SimulationOverridesPlan | undefined {
+    if (!this.pendingCheckpointState && !this.chainTipsOverride && !this.disableBlobCheck) {
+      return undefined;
+    }
+
+    return {
+      chainTipsOverride: this.chainTipsOverride,
+      pendingCheckpointState: this.pendingCheckpointState,
+      disableBlobCheck: this.disableBlobCheck || undefined,
+    };
+  }
+
+  private assertPendingCheckpointNumber(): void {
+    if (this.chainTipsOverride?.pending === undefined) {
+      throw new Error('withChainTips({ pending }) must be called before attaching archive or fee header overrides');
+    }
+  }
+}
+
+/** Translates a simulation plan into the viem state override shape expected by rollup calls. */
+export async function buildSimulationOverridesStateOverride(
+  rollup: RollupContract,
+  plan: SimulationOverridesPlan | undefined,
+): Promise<StateOverride> {
+  if (!plan) {
+    return [];
+  }
+
+  const rollupStateDiff: NonNullable<StateOverride[number]['stateDiff']> = [];
+
+  if (plan.chainTipsOverride) {
+    rollupStateDiff.push(...extractRollupStateDiff(await rollup.makeChainTipsOverride(plan.chainTipsOverride)));
+  }
+
+  if (plan.pendingCheckpointState && plan.chainTipsOverride?.pending === undefined) {
+    throw new Error('pendingCheckpointState requires chainTipsOverride.pending to be set');
+  }
+
+  if (plan.pendingCheckpointState?.archive) {
+    rollupStateDiff.push(
+      ...extractRollupStateDiff(
+        rollup.makeArchiveOverride(plan.chainTipsOverride!.pending!, plan.pendingCheckpointState.archive),
+      ),
+    );
+  }
+
+  if (plan.pendingCheckpointState) {
+    rollupStateDiff.push(
+      ...extractRollupStateDiff(
+        await rollup.makeTempCheckpointLogOverride(plan.chainTipsOverride!.pending!, {
+          headerHash: plan.pendingCheckpointState.headerHash,
+          outHash: plan.pendingCheckpointState.outHash,
+          payloadDigest: plan.pendingCheckpointState.payloadDigest,
+          slotNumber: plan.pendingCheckpointState.slotNumber,
+          feeHeader: plan.pendingCheckpointState.feeHeader,
+        }),
+      ),
+    );
+  }
+
+  if (plan.disableBlobCheck) {
+    rollupStateDiff.push({
+      slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true),
+      value: toPaddedHex(0n, true),
+    });
+  }
+
+  if (rollupStateDiff.length === 0) {
+    return [];
+  }
+
+  return [{ address: rollup.address, stateDiff: rollupStateDiff }];
+}
+
+function extractRollupStateDiff(override: StateOverride | StateOverride[number] | undefined) {
+  const entries = Array.isArray(override) ? override : override ? [override] : [];
+  return entries.flatMap(entry => entry.stateDiff ?? []);
+}

package/src/contracts/empire_base.ts

@@ -22,8 +22,6 @@ export interface IEmpireBase {
     signerAddress: Hex,
     signer: (msg: TypedDataDefinition) => Promise<Hex>,
   ): Promise<L1TxRequest>;
-  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
-  hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean>;
 }
 
 export function encodeSignal(payload: Hex): Hex {

package/src/contracts/fee_asset_price_oracle.ts

@@ -63,28 +63,33 @@ export class FeeAssetPriceOracle {
    *
    * Returns 0 if not on mainnet or if the oracle query fails.
    *
+   * @param currentPriceE12 - Optional override for the parent checkpoint's eth-per-fee-asset
+   *   (E12 scale). When omitted, the latest published value is read from L1. Pipelined
+   *   proposers should supply the predicted parent value so the modifier they emit aligns
+   *   with the parent fee header L1 will see when the previous pipelined checkpoint lands.
    * @returns The price modifier in basis points (positive to increase price, negative to decrease)
    */
-  async computePriceModifier(): Promise<bigint> {
+  async computePriceModifier(currentPriceE12?: bigint): Promise<bigint> {
     const uniswapOracle = await this.getUniswapOracle();
     if (!uniswapOracle) {
       return 0n;
     }
 
     try {
-      // Get current on-chain price (ETH per fee asset, E12)
-      const currentPriceE12 = await this.rollupContract.getEthPerFeeAsset();
+      // Get current on-chain price (ETH per fee asset, E12), preferring the caller-supplied value.
+      const resolvedCurrentPriceE12 = currentPriceE12 ?? (await this.rollupContract.getEthPerFeeAsset());
 
       // Get oracle price (median of last N blocks, ETH per fee asset, E12)
       const oraclePriceE12 = await uniswapOracle.getMeanEthPerFeeAssetE12();
 
       // Compute modifier in basis points
-      const modifier = this.computePriceModifierBps(currentPriceE12, oraclePriceE12);
+      const modifier = this.computePriceModifierBps(resolvedCurrentPriceE12, oraclePriceE12);
 
       this.log.debug('Computed price modifier', {
-        currentPriceE12: currentPriceE12.toString(),
+        currentPriceE12: resolvedCurrentPriceE12.toString(),
         oraclePriceE12: oraclePriceE12.toString(),
         modifierBps: modifier.toString(),
+        currentPriceFromCaller: currentPriceE12 !== undefined,
       });
 
       return modifier;