@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/contracts/rollup.ts

@@ -3,7 +3,6 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
-import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 
 import chunk from 'lodash.chunk';
 import {
@@ -11,8 +10,8 @@ import {
   type GetContractReturnType,
   type Hex,
   type StateOverride,
+  type WatchContractEventReturnType,
   encodeFunctionData,
-  getAddress,
   getContract,
   hexToBigInt,
   keccak256,
@@ -22,7 +21,7 @@ import { getPublicClient } from '../client.js';
 import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { L1ReaderConfig } from '../l1_reader.js';
-import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { EmpireSlashingProposerContract } from './empire_slashing_proposer.js';
@@ -160,13 +159,12 @@ export class RollupContract {
   public async getSlashingProposer(): Promise<
     EmpireSlashingProposerContract | TallySlashingProposerContract | undefined
   > {
-    const slasherAddress = await this.rollup.read.getSlasher();
-    if (EthAddress.fromString(slasherAddress).isZero()) {
+    const slasher = await this.getSlasherContract();
+    if (!slasher) {
       return undefined;
     }
 
-    const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
-    const proposerAddress = await slasher.read.PROPOSER();
+    const proposerAddress = await slasher.getProposer();
     const proposerAbi = [
       {
         type: 'function',
@@ -177,7 +175,7 @@ export class RollupContract {
       },
     ] as const;
 
-    const proposer = getContract({ address: proposerAddress, abi: proposerAbi, client: this.client });
+    const proposer = getContract({ address: proposerAddress.toString(), abi: proposerAbi, client: this.client });
     const proposerType = await proposer.read.SLASHING_PROPOSER_TYPE();
     if (proposerType === SlashingProposerType.Tally.valueOf()) {
       return new TallySlashingProposerContract(this.client, proposerAddress);
@@ -223,6 +221,16 @@ export class RollupContract {
     return this.rollup.read.getEjectionThreshold();
   }
 
+  @memoize
+  getLocalEjectionThreshold() {
+    return this.rollup.read.getLocalEjectionThreshold();
+  }
+
+  @memoize
+  getLagInEpochs() {
+    return this.rollup.read.getLagInEpochs();
+  }
+
   @memoize
   getActivationThreshold() {
     return this.rollup.read.getActivationThreshold();
@@ -260,20 +268,51 @@ export class RollupContract {
 
   @memoize
   async getGenesisArchiveTreeRoot(): Promise<`0x${string}`> {
-    const block = await this.rollup.read.getBlock([0n]);
-    return block.archive;
+    return await this.rollup.read.archiveAt([0n]);
+  }
+
+  /**
+   * 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() {
+  getSlasherAddress() {
     return this.rollup.read.getSlasher();
   }
 
   /**
    * Returns a SlasherContract instance for interacting with the slasher contract.
    */
-  async getSlasherContract(): Promise<SlasherContract> {
-    const slasherAddress = await this.getSlasher();
-    return new SlasherContract(this.client, EthAddress.fromString(slasherAddress));
+  async getSlasherContract(): Promise<SlasherContract | undefined> {
+    const slasherAddress = EthAddress.fromString(await this.getSlasherAddress());
+    if (slasherAddress.isZero()) {
+      return undefined;
+    }
+    return new SlasherContract(this.client, slasherAddress);
   }
 
   getOwner() {
@@ -285,13 +324,11 @@ export class RollupContract {
   }
 
   public async getSlashingProposerAddress() {
-    const slasherAddress = await this.getSlasher();
-    const slasher = getContract({
-      address: getAddress(slasherAddress.toString()),
-      abi: SlasherAbi,
-      client: this.client,
-    });
-    return EthAddress.fromString(await slasher.read.PROPOSER());
+    const slasher = await this.getSlasherContract();
+    if (!slasher) {
+      return EthAddress.ZERO;
+    }
+    return await slasher.getProposer();
   }
 
   getBlockReward() {
@@ -388,8 +425,8 @@ export class RollupContract {
     return result;
   }
 
-  getBlock(blockNumber: bigint) {
-    return this.rollup.read.getBlock([blockNumber]);
+  getBlock(blockNumber: bigint | number) {
+    return this.rollup.read.getBlock([BigInt(blockNumber)]);
   }
 
   getTips() {
@@ -404,8 +441,19 @@ export class RollupContract {
     return this.rollup.read.getEntryQueueLength();
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
+  getAvailableValidatorFlushes() {
+    return this.rollup.read.getAvailableValidatorFlushes();
+  }
+
+  getNextFlushableEpoch() {
+    return this.rollup.read.getNextFlushableEpoch();
+  }
+
+  getCurrentEpochNumber(): Promise<bigint> {
+    return this.rollup.read.getCurrentEpoch();
+  }
+
+  getEpochNumberForBlock(blockNumber: bigint) {
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
   }
 
@@ -461,6 +509,7 @@ export class RollupContract {
       ViemHeader,
       ViemCommitteeAttestations,
       `0x${string}`[],
+      ViemSignature,
       `0x${string}`,
       `0x${string}`,
       {
@@ -483,77 +532,6 @@ export class RollupContract {
     }
   }
 
-  /**
-   * Packs an array of committee attestations into the format expected by the Solidity contract
-   *
-   * @param attestations - Array of committee attestations with addresses and signatures
-   * @returns Packed attestations with bitmap and tightly packed signature/address data
-   */
-  static packAttestations(attestations: ViemCommitteeAttestation[]): ViemCommitteeAttestations {
-    const length = attestations.length;
-
-    // Calculate bitmap size (1 bit per attestation, rounded up to nearest byte)
-    const bitmapSize = Math.ceil(length / 8);
-    const signatureIndices = new Uint8Array(bitmapSize);
-
-    // Calculate total data size needed
-    let totalDataSize = 0;
-    for (let i = 0; i < length; i++) {
-      const signature = attestations[i].signature;
-      // Check if signature is empty (v = 0)
-      const isEmpty = signature.v === 0;
-
-      if (!isEmpty) {
-        totalDataSize += 65; // v (1) + r (32) + s (32)
-      } else {
-        totalDataSize += 20; // address only
-      }
-    }
-
-    const signaturesOrAddresses = new Uint8Array(totalDataSize);
-    let dataIndex = 0;
-
-    // Pack the data
-    for (let i = 0; i < length; i++) {
-      const attestation = attestations[i];
-      const signature = attestation.signature;
-
-      // Check if signature is empty
-      const isEmpty = signature.v === 0;
-
-      if (!isEmpty) {
-        // Set bit in bitmap (bit 7-0 in each byte, left to right)
-        const byteIndex = Math.floor(i / 8);
-        const bitIndex = 7 - (i % 8);
-        signatureIndices[byteIndex] |= 1 << bitIndex;
-
-        // Pack signature: v + r + s
-        signaturesOrAddresses[dataIndex] = signature.v;
-        dataIndex++;
-
-        // Pack r (32 bytes)
-        const rBytes = Buffer.from(signature.r.slice(2), 'hex');
-        signaturesOrAddresses.set(rBytes, dataIndex);
-        dataIndex += 32;
-
-        // Pack s (32 bytes)
-        const sBytes = Buffer.from(signature.s.slice(2), 'hex');
-        signaturesOrAddresses.set(sBytes, dataIndex);
-        dataIndex += 32;
-      } else {
-        // Pack address only (20 bytes)
-        const addrBytes = Buffer.from(attestation.addr.slice(2), 'hex');
-        signaturesOrAddresses.set(addrBytes, dataIndex);
-        dataIndex += 20;
-      }
-    }
-
-    return {
-      signatureIndices: `0x${Buffer.from(signatureIndices).toString('hex')}`,
-      signaturesOrAddresses: `0x${Buffer.from(signaturesOrAddresses).toString('hex')}`,
-    };
-  }
-
   /**
    * @notice  Calls `canProposeAtTime` with the time of the next Ethereum block and the sender address
    *
@@ -618,7 +596,7 @@ export class RollupContract {
   /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
   public buildInvalidateBadAttestationRequest(
     blockNumber: number,
-    attestations: ViemCommitteeAttestation[],
+    attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
     invalidIndex: number,
   ): L1TxRequest {
@@ -629,7 +607,7 @@ export class RollupContract {
         functionName: 'invalidateBadAttestation',
         args: [
           BigInt(blockNumber),
-          RollupContract.packAttestations(attestations),
+          attestationsAndSigners,
           committee.map(addr => addr.toString()),
           BigInt(invalidIndex),
         ],
@@ -640,7 +618,7 @@ export class RollupContract {
   /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
   public buildInvalidateInsufficientAttestationsRequest(
     blockNumber: number,
-    attestations: ViemCommitteeAttestation[],
+    attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
   ): L1TxRequest {
     return {
@@ -648,11 +626,7 @@ export class RollupContract {
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateInsufficientAttestations',
-        args: [
-          BigInt(blockNumber),
-          RollupContract.packAttestations(attestations),
-          committee.map(addr => addr.toString()),
-        ],
+        args: [BigInt(blockNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
       }),
     };
   }
@@ -742,6 +716,10 @@ export class RollupContract {
     return this.rollup.read.getStakingAsset();
   }
 
+  getRewardConfig() {
+    return this.rollup.read.getRewardConfig();
+  }
+
   setupEpoch(l1TxUtils: L1TxUtils) {
     return l1TxUtils.sendAndMonitorTransaction({
       to: this.address,
@@ -764,7 +742,9 @@ export class RollupContract {
     });
   }
 
-  public listenToSlasherChanged(callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown) {
+  public listenToSlasherChanged(
+    callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.SlasherUpdated(
       {},
       {
@@ -780,6 +760,22 @@ export class RollupContract {
     );
   }
 
+  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
+    return this.rollup.watchEvent.BlockInvalidated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.blockNumber !== undefined) {
+              callback({ blockNumber: args.blockNumber });
+            }
+          }
+        },
+      },
+    );
+  }
+
   public async getSlashEvents(l1BlockHash: Hex): Promise<{ amount: bigint; attester: EthAddress }[]> {
     const events = await this.rollup.getEvents.Slashed({}, { blockHash: l1BlockHash, strict: true });
     return events.map(event => ({
@@ -788,7 +784,9 @@ export class RollupContract {
     }));
   }
 
-  public listenToSlash(callback: (args: { amount: bigint; attester: EthAddress }) => unknown) {
+  public listenToSlash(
+    callback: (args: { amount: bigint; attester: EthAddress }) => unknown,
+  ): WatchContractEventReturnType {
     return this.rollup.watchEvent.Slashed(
       {},
       {

package/src/contracts/slasher_contract.ts

@@ -38,6 +38,19 @@ export class SlasherContract {
     }
   }
 
+  /**
+   * Checks if slashing is currently enabled. Slashing can be disabled by the vetoer.
+   * @returns True if slashing is enabled, false otherwise
+   */
+  public async isSlashingEnabled(): Promise<boolean> {
+    try {
+      return await this.contract.read.isSlashingEnabled();
+    } catch (error) {
+      this.log.error(`Error checking if slashing is enabled`, error);
+      throw error;
+    }
+  }
+
   /**
    * Gets the current vetoer address.
    * @returns The vetoer address
@@ -47,6 +60,15 @@ export class SlasherContract {
     return EthAddress.fromString(vetoer);
   }
 
+  /**
+   * Gets the disable duration by the vetoer.
+   * @returns The disable duration in seconds
+   */
+  public async getSlashingDisableDuration(): Promise<number> {
+    const duration = await this.contract.read.SLASHING_DISABLE_DURATION();
+    return Number(duration);
+  }
+
   /**
    * Gets the current governance address.
    * @returns The governance address

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,
@@ -86,11 +85,20 @@ export class TallySlashingProposerContract extends EventEmitter {
    */
   public async getRound(round: bigint): Promise<{
     isExecuted: boolean;
-    readyToExecute: boolean;
     voteCount: bigint;
   }> {
-    const [isExecuted, readyToExecute, voteCount] = await this.contract.read.getRound([round]);
-    return { isExecuted, readyToExecute, voteCount };
+    const [isExecuted, voteCount] = await this.contract.read.getRound([round]);
+    return { isExecuted, voteCount };
+  }
+
+  /**
+   * Check if a round is ready to execute at a given slot
+   * @param round - The round number to check
+   * @param slot - The slot number to check at
+   * @returns Whether the round is ready to execute
+   */
+  public async isRoundReadyToExecute(round: bigint, slot: bigint): Promise<boolean> {
+    return await this.contract.read.isRoundReadyToExecute([round, slot]);
   }
 
   /** Returns the slash actions and payload address for a given round (zero if no slash actions) */
@@ -221,6 +229,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 +288,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;
+}