@aztec/ethereum 0.0.1-commit.1142ef1 → 0.0.1-commit.18ccd8f0

package/src/contracts/rollup.ts

@@ -5,6 +5,7 @@ import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { EscapeHatchAbi } from '@aztec/l1-artifacts/EscapeHatchAbi';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
 
@@ -30,6 +31,7 @@ import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { EmpireSlashingProposerContract } from './empire_slashing_proposer.js';
 import { GSEContract } from './gse.js';
+import type { L1EventLog } from './log.js';
 import { SlasherContract } from './slasher_contract.js';
 import { TallySlashingProposerContract } from './tally_slashing_proposer.js';
 import { checkBlockTag } from './utils.js';
@@ -69,6 +71,7 @@ export type ViemHeader = {
   blockHeadersHash: `0x${string}`;
   blobsHash: `0x${string}`;
   inHash: `0x${string}`;
+  outHash: `0x${string}`;
   slotNumber: bigint;
   timestamp: bigint;
   coinbase: `0x${string}`;
@@ -105,7 +108,7 @@ export enum AttesterStatus {
 export type FeeHeader = {
   excessMana: bigint;
   manaUsed: bigint;
-  feeAssetPriceNumerator: bigint;
+  ethPerFeeAsset: bigint;
   congestionCost: bigint;
   proverCost: bigint;
 };
@@ -185,10 +188,28 @@ export type RollupStatusResponse = {
   archiveOfMyCheckpoint: Fr;
 };
 
+/** Arguments for the CheckpointProposed event. */
+export type CheckpointProposedArgs = {
+  checkpointNumber: CheckpointNumber;
+  archive: Fr;
+  versionedBlobHashes: Buffer[];
+  /** Hash of attestations. Undefined for older events (backwards compatibility). */
+  attestationsHash?: Buffer32;
+  /** Digest of the payload. Undefined for older events (backwards compatibility). */
+  payloadDigest?: Buffer32;
+};
+
+/** Log type for CheckpointProposed events. */
+export type CheckpointProposedLog = L1EventLog<CheckpointProposedArgs>;
+
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
 
   private static cachedStfStorageSlot: Hex | undefined;
+  private cachedEscapeHatch?: {
+    address: EthAddress;
+    contract: GetContractReturnType<typeof EscapeHatchAbi, ViemClient>;
+  };
 
   static get checkBlobStorageSlot(): bigint {
     const asString = RollupStorage.find(storage => storage.label === 'checkBlob')?.slot;
@@ -391,6 +412,58 @@ export class RollupContract {
     return EthAddress.fromString(await this.rollup.read.getSlasher());
   }
 
+  /**
+   * Returns the configured escape hatch contract address, or zero if disabled.
+   */
+  async getEscapeHatchAddress(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.rollup.read.getEscapeHatch());
+  }
+
+  private async getEscapeHatchContract(): Promise<
+    GetContractReturnType<typeof EscapeHatchAbi, ViemClient> | undefined
+  > {
+    const escapeHatchAddress = await this.getEscapeHatchAddress();
+    if (escapeHatchAddress.isZero()) {
+      return undefined;
+    }
+
+    // Cache the viem contract wrapper since it will be used frequently.
+    if (!this.cachedEscapeHatch || !this.cachedEscapeHatch.address.equals(escapeHatchAddress)) {
+      this.cachedEscapeHatch = {
+        address: escapeHatchAddress,
+        contract: getContract({
+          address: escapeHatchAddress.toString(),
+          abi: EscapeHatchAbi,
+          client: this.client,
+        }),
+      };
+    }
+
+    return this.cachedEscapeHatch.contract;
+  }
+
+  /**
+   * Returns whether the escape hatch is open for the given epoch.
+   * If escape hatch is not configured, returns false.
+   *
+   * This function is intentionally defensive: any failure to query the escape hatch
+   * (RPC issues, transient errors, etc.) is treated as "closed" to avoid callers
+   * needing to sprinkle try/catch everywhere.
+   */
+  async isEscapeHatchOpen(epoch: EpochNumber): Promise<boolean> {
+    try {
+      const escapeHatch = await this.getEscapeHatchContract();
+      if (!escapeHatch) {
+        return false;
+      }
+
+      const [isOpen] = await escapeHatch.read.isHatchOpen([BigInt(epoch)]);
+      return isOpen;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Returns a SlasherContract instance for interacting with the slasher contract.
    */
@@ -442,8 +515,8 @@ export class RollupContract {
     };
   }
 
-  getFeeAssetPerEth(): Promise<bigint> {
-    return this.rollup.read.getFeeAssetPerEth();
+  getEthPerFeeAsset(): Promise<bigint> {
+    return this.rollup.read.getEthPerFeeAsset();
   }
 
   async getCommitteeAt(timestamp: bigint): Promise<EthAddress[] | undefined> {
@@ -528,7 +601,7 @@ export class RollupContract {
       feeHeader: {
         excessMana: result.feeHeader.excessMana,
         manaUsed: result.feeHeader.manaUsed,
-        feeAssetPriceNumerator: result.feeHeader.feeAssetPriceNumerator,
+        ethPerFeeAsset: result.feeHeader.ethPerFeeAsset,
         congestionCost: result.feeHeader.congestionCost,
         proverCost: result.feeHeader.proverCost,
       },
@@ -965,4 +1038,23 @@ export class RollupContract {
       },
     );
   }
+
+  /** Fetches CheckpointProposed events within the given block range. */
+  async getCheckpointProposedEvents(fromBlock: bigint, toBlock: bigint): Promise<CheckpointProposedLog[]> {
+    const logs = await this.rollup.getEvents.CheckpointProposed({}, { fromBlock, toBlock });
+    return logs
+      .filter(log => log.blockNumber! >= fromBlock && log.blockNumber! <= toBlock)
+      .map(log => ({
+        l1BlockNumber: log.blockNumber!,
+        l1BlockHash: Buffer32.fromString(log.blockHash!),
+        l1TransactionHash: log.transactionHash!,
+        args: {
+          checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
+          archive: Fr.fromString(log.args.archive!),
+          versionedBlobHashes: log.args.versionedBlobHashes!.map(h => Buffer.from(h.slice(2), 'hex')),
+          attestationsHash: log.args.attestationsHash ? Buffer32.fromString(log.args.attestationsHash) : undefined,
+          payloadDigest: log.args.payloadDigest ? Buffer32.fromString(log.args.payloadDigest) : undefined,
+        },
+      }));
+  }
 }

package/src/deploy_aztec_l1_contracts.ts

@@ -10,7 +10,7 @@ import { fileURLToPath } from '@aztec/foundation/url';
 import { bn254 } from '@noble/curves/bn254';
 import type { Abi, Narrow } from 'abitype';
 import { spawn } from 'child_process';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from 'fs';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { dirname, join, resolve } from 'path';
 import readline from 'readline';
@@ -141,11 +141,14 @@ function cleanupDeployDir() {
  */
 export function prepareL1ContractsForDeployment(): string {
   if (preparedDeployDir && existsSync(preparedDeployDir)) {
+    logger.verbose(`Using cached deployment directory: ${preparedDeployDir}`);
     return preparedDeployDir;
   }
 
   const basePath = getL1ContractsPath();
+  logger.verbose(`Preparing L1 contracts from: ${basePath}`);
   const tempDir = mkdtempSync(join(tmpdir(), '.foundry-deploy-'));
+  logger.verbose(`Created temp directory for deployment: ${tempDir}`);
   preparedDeployDir = tempDir;
   process.on('exit', cleanupDeployDir);
 
@@ -157,13 +160,21 @@ export function prepareL1ContractsForDeployment(): string {
   cpSync(join(basePath, 'src'), join(tempDir, 'src'), copyOpts);
   cpSync(join(basePath, 'script'), join(tempDir, 'script'), copyOpts);
   cpSync(join(basePath, 'generated'), join(tempDir, 'generated'), copyOpts);
-  cpSync(join(basePath, 'foundry.toml'), join(tempDir, 'foundry.toml'));
+  // Kludge: copy test/ to appease forge cache which references test/shouting.t.sol
+  cpSync(join(basePath, 'test'), join(tempDir, 'test'), copyOpts);
   cpSync(join(basePath, 'foundry.lock'), join(tempDir, 'foundry.lock'));
-  for (const file of readdirSync(basePath)) {
-    if (file.startsWith('solc-')) {
-      cpSync(join(basePath, file), join(tempDir, file));
-    }
+
+  // Update foundry.toml to use absolute path to solc binary (avoids copying to noexec tmpfs)
+  const foundryTomlPath = join(basePath, 'foundry.toml');
+  let foundryToml = readFileSync(foundryTomlPath, 'utf-8');
+  const solcPathMatch = foundryToml.match(/solc\s*=\s*"\.\/solc-([^"]+)"/);
+  if (solcPathMatch) {
+    const solcVersion = solcPathMatch[1];
+    const absoluteSolcPath = join(basePath, `solc-${solcVersion}`);
+    foundryToml = foundryToml.replace(/solc\s*=\s*"\.\/solc-[^"]+"/, `solc = "${absoluteSolcPath}"`);
+    logger.verbose(`Updated solc path in foundry.toml to: ${absoluteSolcPath}`);
   }
+  writeFileSync(join(tempDir, 'foundry.toml'), foundryToml);
 
   mkdirSync(join(tempDir, 'broadcast'));
   return tempDir;
@@ -308,7 +319,7 @@ export async function deployAztecL1Contracts(
   }
 
   // From heuristic testing. More caused issues with anvil.
-  const MAGIC_ANVIL_BATCH_SIZE = 12;
+  const MAGIC_ANVIL_BATCH_SIZE = 8;
   // Anvil seems to stall with unbounded batch size. Otherwise no max batch size is desirable.
   const forgeArgs = [
     'script',
@@ -497,6 +508,7 @@ export function getDeployAztecL1ContractsEnvVars(args: DeployAztecL1ContractsArg
     AZTEC_EJECTION_THRESHOLD: args.ejectionThreshold?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: args.governanceProposerRoundSize?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_QUORUM: args.governanceProposerQuorum?.toString(),
+    AZTEC_GOVERNANCE_VOTING_DURATION: args.governanceVotingDuration?.toString(),
     ZKPASSPORT_DOMAIN: args.zkPassportArgs?.zkPassportDomain,
     ZKPASSPORT_SCOPE: args.zkPassportArgs?.zkPassportScope,
   } as const;
@@ -531,11 +543,13 @@ export function getDeployRollupForUpgradeEnvVars(
     AZTEC_PROOF_SUBMISSION_EPOCHS: args.aztecProofSubmissionEpochs.toString(),
     AZTEC_LOCAL_EJECTION_THRESHOLD: args.localEjectionThreshold.toString(),
     AZTEC_SLASHING_LIFETIME_IN_ROUNDS: args.slashingLifetimeInRounds.toString(),
+    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: args.slashingExecutionDelayInRounds.toString(),
     AZTEC_SLASHING_VETOER: args.slashingVetoer.toString(),
     AZTEC_SLASHING_DISABLE_DURATION: args.slashingDisableDuration.toString(),
     AZTEC_MANA_TARGET: args.manaTarget.toString(),
     AZTEC_EXIT_DELAY_SECONDS: args.exitDelaySeconds.toString(),
     AZTEC_PROVING_COST_PER_MANA: args.provingCostPerMana.toString(),
+    AZTEC_INITIAL_ETH_PER_FEE_ASSET: args.initialEthPerFeeAsset.toString(),
     AZTEC_SLASHER_FLAVOR: args.slasherFlavor,
     AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: args.slashingRoundSizeInEpochs.toString(),
     AZTEC_SLASHING_QUORUM: args.slashingQuorum?.toString(),

package/src/generated/l1-contracts-defaults.ts

@@ -0,0 +1,32 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+/** Default L1 contracts configuration values from network-defaults.yml */
+export const l1ContractsDefaultEnv = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_SLOT_DURATION: 36,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
+} as const;

package/src/publisher_manager.ts

@@ -1,5 +1,5 @@
 import { pick } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 
 import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
@@ -28,13 +28,15 @@ const busyStates: TxUtilsState[] = [
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-  private log = createLogger('publisher:manager');
+  private log: Logger;
   private config: { publisherAllowInvalidStates?: boolean };
 
   constructor(
     private publishers: UtilsType[],
     config: { publisherAllowInvalidStates?: boolean },
+    bindings?: LoggerBindings,
   ) {
+    this.log = createLogger('publisher:manager', bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
     this.config = pick(config, 'publisherAllowInvalidStates');

package/src/queries.ts

@@ -1,6 +1,6 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L1ContractsConfig } from './config.js';
+import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { InboxContract } from './contracts/inbox.js';
@@ -99,6 +99,7 @@ export async function getL1ContractsConfig(
     inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -118,5 +119,6 @@ export async function getL1ContractsConfig(
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }

package/src/test/rollup_cheat_codes.ts

@@ -56,6 +56,15 @@ export class RollupCheatCodes {
     return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([ts]));
   }
 
+  /** Returns the number of seconds until the start of the given slot based on L1 block timestamp. */
+  public async getSecondsUntilSlot(slot: SlotNumber): Promise<number> {
+    const [currentTimestamp, targetTimestamp] = await Promise.all([
+      this.client.getBlock().then(b => BigInt(b.timestamp)),
+      this.rollup.read.getTimestampForSlot([BigInt(slot)]),
+    ]);
+    return Math.max(0, Number(targetTimestamp - currentTimestamp));
+  }
+
   /** Returns the current epoch */
   public async getEpoch(): Promise<EpochNumber> {
     const slotNumber = await this.getSlot();
@@ -124,7 +133,7 @@ export class RollupCheatCodes {
     } = {},
   ) {
     const { epochDuration: slotsInEpoch } = await this.getConfig();
-    const slotNumber = SlotNumber(epoch * Number(slotsInEpoch));
+    const slotNumber = SlotNumber(Number(epoch) * Number(slotsInEpoch));
     const timestamp = (await this.rollup.read.getTimestampForSlot([BigInt(slotNumber)])) + BigInt(opts.offset ?? 0);
     try {
       await this.ethCheatCodes.warp(Number(timestamp), { ...opts, silent: true, resetBlockInterval: true });
@@ -176,7 +185,7 @@ export class RollupCheatCodes {
    * Marks the specified checkpoint (or latest if none) as proven
    * @param maybeCheckpointNumber - The checkpoint number to mark as proven (defaults to latest pending)
    */
-  public markAsProven(maybeCheckpointNumber?: number | bigint) {
+  public markAsProven(maybeCheckpointNumber?: CheckpointNumber) {
     return this.ethCheatCodes.execWithPausedAnvil(async () => {
       const tipsBefore = await this.getTips();
       const { pending, proven } = tipsBefore;

package/src/test/start_anvil.ts

@@ -33,7 +33,7 @@ export async function startAnvil(
       const anvil = createAnvil({
         anvilBinary,
         host: '127.0.0.1',
-        port: opts.port ?? 8545,
+        port: opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545),
         blockTime: opts.l1BlockTime,
         stopTimeout: 1000,
         accounts: opts.accounts ?? 20,