@aztec/ethereum 3.0.0-nightly.20250904 → 3.0.0-nightly.20250906

package/src/config.ts

@@ -118,10 +118,15 @@ const TestnetGovernanceConfiguration = {
 };
 
 export const getGovernanceConfiguration = (networkName: NetworkNames) => {
-  if (networkName === 'alpha-testnet' || networkName === 'testnet') {
-    return TestnetGovernanceConfiguration;
+  switch (networkName) {
+    case 'alpha-testnet':
+    case 'testnet':
+      return TestnetGovernanceConfiguration;
+    case 'local':
+      return LocalGovernanceConfiguration;
+    default:
+      throw new Error('Unrecognized network name: ' + networkName);
   }
-  return LocalGovernanceConfiguration;
 };
 
 const TestnetGSEConfiguration = {
@@ -135,10 +140,15 @@ const LocalGSEConfiguration = {
 };
 
 export const getGSEConfiguration = (networkName: NetworkNames) => {
-  if (networkName === 'alpha-testnet' || networkName === 'testnet') {
-    return TestnetGSEConfiguration;
+  switch (networkName) {
+    case 'alpha-testnet':
+    case 'testnet':
+      return TestnetGSEConfiguration;
+    case 'local':
+      return LocalGSEConfiguration;
+    default:
+      throw new Error('Unrecognized network name: ' + networkName);
   }
-  return LocalGSEConfiguration;
 };
 
 // Making a default config here as we are only using it thought the deployment
@@ -159,10 +169,15 @@ const TestnetRewardConfig = {
 };
 
 export const getRewardConfig = (networkName: NetworkNames) => {
-  if (networkName === 'alpha-testnet' || networkName === 'testnet') {
-    return TestnetRewardConfig;
+  switch (networkName) {
+    case 'alpha-testnet':
+    case 'testnet':
+      return TestnetRewardConfig;
+    case 'local':
+      return LocalRewardConfig;
+    default:
+      throw new Error('Unrecognized network name: ' + networkName);
   }
-  return LocalRewardConfig;
 };
 
 const LocalRewardBoostConfig = {
@@ -182,10 +197,15 @@ const TestnetRewardBoostConfig = {
 };
 
 export const getRewardBoostConfig = (networkName: NetworkNames) => {
-  if (networkName === 'alpha-testnet' || networkName === 'testnet') {
-    return TestnetRewardBoostConfig;
+  switch (networkName) {
+    case 'alpha-testnet':
+    case 'testnet':
+      return TestnetRewardBoostConfig;
+    case 'local':
+      return LocalRewardBoostConfig;
+    default:
+      throw new Error('Unrecognized network name: ' + networkName);
   }
-  return LocalRewardBoostConfig;
 };
 
 // Similar to the above, no need for environment variables for this.
@@ -206,10 +226,15 @@ const TestnetEntryQueueConfig = {
 };
 
 export const getEntryQueueConfig = (networkName: NetworkNames) => {
-  if (networkName === 'alpha-testnet' || networkName === 'testnet') {
-    return TestnetEntryQueueConfig;
+  switch (networkName) {
+    case 'alpha-testnet':
+    case 'testnet':
+      return TestnetEntryQueueConfig;
+    case 'local':
+      return LocalEntryQueueConfig;
+    default:
+      throw new Error('Unrecognized network name: ' + networkName);
   }
-  return LocalEntryQueueConfig;
 };
 
 export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> = {

package/src/contracts/rollup.ts

@@ -264,6 +264,35 @@ export class RollupContract {
     return block.archive;
   }
 
+  /**
+   * Returns rollup constants used for epoch queries.
+   * Return type is `L1RollupConstants` which is defined in stdlib,
+   * so we cant reference it until we move this contract to that package.
+   */
+  @memoize
+  public async getRollupConstants(): Promise<{
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+    slotDuration: number;
+    epochDuration: number;
+    proofSubmissionEpochs: number;
+  }> {
+    const [l1StartBlock, l1GenesisTime, slotDuration, epochDuration, proofSubmissionEpochs] = await Promise.all([
+      this.getL1StartBlock(),
+      this.getL1GenesisTime(),
+      this.getSlotDuration(),
+      this.getEpochDuration(),
+      this.getProofSubmissionEpochs(),
+    ]);
+    return {
+      l1StartBlock,
+      l1GenesisTime,
+      slotDuration: Number(slotDuration),
+      epochDuration: Number(epochDuration),
+      proofSubmissionEpochs: Number(proofSubmissionEpochs),
+    };
+  }
+
   getSlasher() {
     return this.rollup.read.getSlasher();
   }

package/src/contracts/tally_slashing_proposer.ts

@@ -2,9 +2,9 @@ import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ether
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
+import { hexToBuffer } from '@aztec/foundation/string';
 import { TallySlashingProposerAbi } from '@aztec/l1-artifacts/TallySlashingProposerAbi';
 
-import EventEmitter from 'events';
 import {
   type GetContractReturnType,
   type Hex,
@@ -18,7 +18,7 @@ import {
  * Wrapper around the TallySlashingProposer contract that provides
  * a TypeScript interface for interacting with the consensus-based slashing system.
  */
-export class TallySlashingProposerContract extends EventEmitter {
+export class TallySlashingProposerContract {
   private readonly contract: GetContractReturnType<typeof TallySlashingProposerAbi, ViemClient>;
 
   public readonly type = 'tally' as const;
@@ -27,7 +27,6 @@ export class TallySlashingProposerContract extends EventEmitter {
     public readonly client: ViemClient,
     address: Hex | EthAddress,
   ) {
-    super();
     this.contract = getContract({
       address: typeof address === 'string' ? address : address.toString(),
       abi: TallySlashingProposerAbi,
@@ -221,6 +220,21 @@ export class TallySlashingProposerContract extends EventEmitter {
     };
   }
 
+  /** Returns the last vote emitted for a given round  */
+  public async getLastVote(round: bigint) {
+    const { voteCount } = await this.getRound(round);
+    const validators = (await this.contract.simulate.getSlashTargetCommittees([round])).result.flat();
+    const vote = await this.contract.read.getVotes([round, voteCount - 1n]);
+    const decoded = decodeSlashConsensusVotes(hexToBuffer(vote));
+    const slashAmounts = await this.getSlashingAmounts();
+    return decoded
+      .map((units, i) => ({
+        validator: EthAddress.fromString(validators[i]),
+        slashAmount: slashAmounts[units - 1] ?? 0n,
+      }))
+      .filter(v => v.slashAmount > 0n);
+  }
+
   /**
    * Listen for VoteCast events
    * @param callback - Callback function to handle vote cast events
@@ -265,3 +279,28 @@ export class TallySlashingProposerContract extends EventEmitter {
     );
   }
 }
+
+/**
+ * Decodes a Buffer containing slash votes back into an array of numbers.
+ * Each vote is represented as a 2-bit value (0, 1, 2, or 3) representing slashing units.
+ * @dev This should live in stdlib next to encodeSlashConsensusVotes but is here since we
+ * do not have a dependency to stdlib from the ethereum package. We need a larger refactor to fix this.
+ * @param buffer - The Buffer containing encoded slash votes
+ * @returns An array of numbers representing the slash votes
+ */
+export function decodeSlashConsensusVotes(buffer: Buffer): number[] {
+  const votes: number[] = [];
+  for (let i = 0; i < buffer.length; i++) {
+    const voteByte = buffer.readUInt8(i);
+    // Decode votes from Solidity's bit order (LSB to MSB)
+    // Bits 0-1: validator at index i*4
+    // Bits 2-3: validator at index i*4+1
+    // Bits 4-5: validator at index i*4+2
+    // Bits 6-7: validator at index i*4+3
+    votes.push((voteByte >> 0) & 0x03);
+    votes.push((voteByte >> 2) & 0x03);
+    votes.push((voteByte >> 4) & 0x03);
+    votes.push((voteByte >> 6) & 0x03);
+  }
+  return votes;
+}

package/src/l1_contract_addresses.ts

@@ -58,73 +58,62 @@ const parseEnv = (val: string) => EthAddress.fromString(val);
 export const l1ContractAddressesMapping: ConfigMappingsType<
   Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress'>
 > = {
-  rollupAddress: {
-    env: 'ROLLUP_CONTRACT_ADDRESS',
-    description: 'The deployed L1 rollup contract address.',
-    parseEnv,
-  },
   registryAddress: {
     env: 'REGISTRY_CONTRACT_ADDRESS',
     description: 'The deployed L1 registry contract address.',
     parseEnv,
   },
+  slashFactoryAddress: {
+    env: 'SLASH_FACTORY_CONTRACT_ADDRESS',
+    description: 'The deployed L1 slashFactory contract address',
+    parseEnv,
+  },
+  feeAssetHandlerAddress: {
+    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
+    description: 'The deployed L1 feeAssetHandler contract address',
+    parseEnv,
+  },
+  rollupAddress: {
+    description: 'The deployed L1 rollup contract address.',
+    parseEnv,
+  },
   inboxAddress: {
-    env: 'INBOX_CONTRACT_ADDRESS',
     description: 'The deployed L1 inbox contract address.',
     parseEnv,
   },
   outboxAddress: {
-    env: 'OUTBOX_CONTRACT_ADDRESS',
     description: 'The deployed L1 outbox contract address.',
     parseEnv,
   },
   feeJuiceAddress: {
-    env: 'FEE_JUICE_CONTRACT_ADDRESS',
     description: 'The deployed L1 Fee Juice contract address.',
     parseEnv,
   },
   stakingAssetAddress: {
-    env: 'STAKING_ASSET_CONTRACT_ADDRESS',
     description: 'The deployed L1 staking asset contract address.',
     parseEnv,
   },
   feeJuicePortalAddress: {
-    env: 'FEE_JUICE_PORTAL_CONTRACT_ADDRESS',
     description: 'The deployed L1 Fee Juice portal contract address.',
     parseEnv,
   },
   coinIssuerAddress: {
-    env: 'COIN_ISSUER_CONTRACT_ADDRESS',
     description: 'The deployed L1 coinIssuer contract address',
     parseEnv,
   },
   rewardDistributorAddress: {
-    env: 'REWARD_DISTRIBUTOR_CONTRACT_ADDRESS',
     description: 'The deployed L1 rewardDistributor contract address',
     parseEnv,
   },
   governanceProposerAddress: {
-    env: 'GOVERNANCE_PROPOSER_CONTRACT_ADDRESS',
     description: 'The deployed L1 governanceProposer contract address',
     parseEnv,
   },
   governanceAddress: {
-    env: 'GOVERNANCE_CONTRACT_ADDRESS',
     description: 'The deployed L1 governance contract address',
     parseEnv,
   },
-  slashFactoryAddress: {
-    env: 'SLASH_FACTORY_CONTRACT_ADDRESS',
-    description: 'The deployed L1 slashFactory contract address',
-    parseEnv,
-  },
-  feeAssetHandlerAddress: {
-    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
-    description: 'The deployed L1 feeAssetHandler contract address',
-    parseEnv,
-  },
   stakingAssetHandlerAddress: {
-    env: 'STAKING_ASSET_HANDLER_CONTRACT_ADDRESS',
     description: 'The deployed L1 stakingAssetHandler contract address',
     parseEnv,
   },

package/src/l1_reader.ts

@@ -15,20 +15,20 @@ export interface L1ReaderConfig {
 }
 
 export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
-  l1RpcUrls: {
-    env: 'ETHEREUM_HOSTS',
-    description: 'The RPC Url of the ethereum host.',
-    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+  l1Contracts: {
+    description: 'The deployed L1 contract addresses',
+    nested: l1ContractAddressesMapping,
   },
   l1ChainId: {
     env: 'L1_CHAIN_ID',
     parseEnv: (val: string) => +val,
-    defaultValue: 31337,
     description: 'The chain ID of the ethereum host.',
   },
-  l1Contracts: {
-    description: 'The deployed L1 contract addresses',
-    nested: l1ContractAddressesMapping,
+  l1RpcUrls: {
+    env: 'ETHEREUM_HOSTS',
+    description: 'The RPC Url of the ethereum host.',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+    defaultValue: [],
   },
   viemPollingIntervalMS: {
     env: 'L1_READER_VIEM_POLLING_INTERVAL_MS',

package/src/test/chain_monitor.ts

@@ -14,6 +14,7 @@ export type ChainMonitorEventMap = {
   'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: number; timestamp: bigint }];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -38,6 +39,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
   public totalL2Messages: number = 0;
   /** Current L2 epoch number */
   public l2EpochNumber!: bigint;
+  /** Current L2 slot number */
+  public l2SlotNumber!: bigint;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -143,7 +146,12 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.l2EpochNumber = l2Epoch;
       committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
       this.emit('l2-epoch', { l2EpochNumber: Number(l2Epoch), timestamp, committee });
-      msg += ` starting new epoch ${this.l2EpochNumber} with committee ${committee?.join(', ') ?? 'undefined'}`;
+      msg += ` starting new epoch ${this.l2EpochNumber} `;
+    }
+
+    if (l2SlotNumber !== this.l2SlotNumber) {
+      this.l2SlotNumber = l2SlotNumber;
+      this.emit('l2-slot', { l2SlotNumber: Number(l2SlotNumber), timestamp });
     }
 
     this.logger.info(msg, {
@@ -160,4 +168,20 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
     return this;
   }
+
+  public waitUntilL2Slot(slot: number | bigint): Promise<void> {
+    const targetSlot = typeof slot === 'bigint' ? slot.valueOf() : slot;
+    if (this.l2SlotNumber >= targetSlot) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2SlotNumber: number; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= targetSlot) {
+          this.off('l2-slot', listener);
+          resolve();
+        }
+      };
+      this.on('l2-slot', listener);
+    });
+  }
 }