@aztec/ethereum 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/contracts/rollup.ts

@@ -1,17 +1,46 @@
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
-import { RollupAbi, RollupStorage, SlasherAbi } from '@aztec/l1-artifacts';
-
-import { type Account, type GetContractReturnType, type Hex, getAddress, getContract } from 'viem';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
+
+import chunk from 'lodash.chunk';
+import {
+  type Account,
+  type GetContractReturnType,
+  type Hex,
+  type StateOverride,
+  type WatchContractEventReturnType,
+  encodeFunctionData,
+  getContract,
+  hexToBigInt,
+  keccak256,
+} from 'viem';
 
 import { getPublicClient } from '../client.js';
-import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
+import type { DeployAztecL1ContractsReturnType } from '../deploy_aztec_l1_contracts.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { L1ReaderConfig } from '../l1_reader.js';
-import type { ViemPublicClient } from '../types.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
-import { SlashingProposerContract } from './slashing_proposer.js';
+import { EmpireSlashingProposerContract } from './empire_slashing_proposer.js';
+import { GSEContract } from './gse.js';
+import { SlasherContract } from './slasher_contract.js';
+import { TallySlashingProposerContract } from './tally_slashing_proposer.js';
+import { checkBlockTag } from './utils.js';
+
+export type ViemCommitteeAttestation = {
+  addr: `0x${string}`;
+  signature: ViemSignature;
+};
+
+export type ViemCommitteeAttestations = {
+  signatureIndices: `0x${string}`;
+  signaturesOrAddresses: `0x${string}`;
+};
 
 export type L1RollupContractAddresses = Pick<
   L1ContractAddresses,
@@ -23,20 +52,48 @@ export type L1RollupContractAddresses = Pick<
   | 'stakingAssetAddress'
   | 'rewardDistributorAddress'
   | 'slashFactoryAddress'
+  | 'gseAddress'
 >;
 
 export type EpochProofPublicInputArgs = {
   previousArchive: `0x${string}`;
   endArchive: `0x${string}`;
-  previousBlockHash: `0x${string}`;
-  endBlockHash: `0x${string}`;
-  endTimestamp: bigint;
-  outHash: `0x${string}`;
   proverId: `0x${string}`;
 };
 
+export type ViemHeader = {
+  lastArchiveRoot: `0x${string}`;
+  blockHeadersHash: `0x${string}`;
+  contentCommitment: ViemContentCommitment;
+  slotNumber: bigint;
+  timestamp: bigint;
+  coinbase: `0x${string}`;
+  feeRecipient: `0x${string}`;
+  gasFees: ViemGasFees;
+  totalManaUsed: bigint;
+};
+
+export type ViemContentCommitment = {
+  blobsHash: `0x${string}`;
+  inHash: `0x${string}`;
+  outHash: `0x${string}`;
+};
+
+export type ViemGasFees = {
+  feePerDaGas: bigint;
+  feePerL2Gas: bigint;
+};
+
+export enum SlashingProposerType {
+  None = 0,
+  Tally = 1,
+  Empire = 2,
+}
+
 export class RollupContract {
-  private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>;
+  private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
+
+  private static cachedStfStorageSlot: Hex | undefined;
 
   static get checkBlobStorageSlot(): bigint {
     const asString = RollupStorage.find(storage => storage.label === 'checkBlob')?.slot;
@@ -46,12 +103,16 @@ export class RollupContract {
     return BigInt(asString);
   }
 
-  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1ContractsReturnType) {
+  static get stfStorageSlot(): Hex {
+    return (RollupContract.cachedStfStorageSlot ??= keccak256(Buffer.from('aztec.stf.storage', 'utf-8')));
+  }
+
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployAztecL1ContractsReturnType) {
     const {
-      publicClient,
+      l1Client,
       l1ContractAddresses: { rollupAddress },
     } = deployL1ContractsValues;
-    return new RollupContract(publicClient, rollupAddress.toString());
+    return new RollupContract(l1Client, rollupAddress.toString());
   }
 
   static getFromConfig(config: L1ReaderConfig) {
@@ -60,23 +121,56 @@ export class RollupContract {
     return new RollupContract(client, address);
   }
 
-  constructor(public readonly client: ViemPublicClient, address: Hex | EthAddress) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
     this.rollup = getContract({ address, abi: RollupAbi, client });
   }
 
+  getGSE() {
+    return this.rollup.read.getGSE();
+  }
+
   public get address() {
     return this.rollup.address;
   }
 
-  @memoize
-  public async getSlashingProposer() {
-    const slasherAddress = await this.rollup.read.getSlasher();
-    const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
-    const proposerAddress = await slasher.read.PROPOSER();
-    return new SlashingProposerContract(this.client, proposerAddress);
+  getContract(): GetContractReturnType<typeof RollupAbi, ViemClient> {
+    return this.rollup;
+  }
+
+  public async getSlashingProposer(): Promise<
+    EmpireSlashingProposerContract | TallySlashingProposerContract | undefined
+  > {
+    const slasher = await this.getSlasherContract();
+    if (!slasher) {
+      return undefined;
+    }
+
+    const proposerAddress = await slasher.getProposer();
+    const proposerAbi = [
+      {
+        type: 'function',
+        name: 'SLASHING_PROPOSER_TYPE',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint8', internalType: 'enum SlasherFlavor' }],
+        stateMutability: 'view',
+      },
+    ] as const;
+
+    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);
+    } else if (proposerType === SlashingProposerType.Empire.valueOf()) {
+      return new EmpireSlashingProposerContract(this.client, proposerAddress);
+    } else {
+      throw new Error(`Unknown slashing proposer type: ${proposerType}`);
+    }
   }
 
   @memoize
@@ -90,8 +184,8 @@ export class RollupContract {
   }
 
   @memoize
-  getProofSubmissionWindow() {
-    return this.rollup.read.getProofSubmissionWindow();
+  getProofSubmissionEpochs() {
+    return this.rollup.read.getProofSubmissionEpochs();
   }
 
   @memoize
@@ -100,8 +194,8 @@ export class RollupContract {
   }
 
   @memoize
-  getSlotDuration() {
-    return this.rollup.read.getSlotDuration();
+  async getSlotDuration(): Promise<number> {
+    return Number(await this.rollup.read.getSlotDuration());
   }
 
   @memoize
@@ -110,34 +204,165 @@ export class RollupContract {
   }
 
   @memoize
-  getMinimumStake() {
-    return this.rollup.read.getMinimumStake();
+  getEjectionThreshold() {
+    return this.rollup.read.getEjectionThreshold();
+  }
+
+  @memoize
+  getLocalEjectionThreshold() {
+    return this.rollup.read.getLocalEjectionThreshold();
+  }
+
+  @memoize
+  getLagInEpochsForValidatorSet() {
+    return this.rollup.read.getLagInEpochsForValidatorSet();
+  }
+
+  @memoize
+  getLagInEpochsForRandao() {
+    return this.rollup.read.getLagInEpochsForRandao();
+  }
+
+  @memoize
+  getActivationThreshold() {
+    return this.rollup.read.getActivationThreshold();
+  }
+
+  @memoize
+  getExitDelay() {
+    return this.rollup.read.getExitDelay();
+  }
+
+  @memoize
+  getManaTarget() {
+    return this.rollup.read.getManaTarget();
+  }
+
+  @memoize
+  getProvingCostPerMana() {
+    return this.rollup.read.getProvingCostPerManaInEth();
+  }
+
+  @memoize
+  getProvingCostPerManaInFeeAsset() {
+    return this.rollup.read.getProvingCostPerManaInFeeAsset();
+  }
+
+  @memoize
+  getManaLimit() {
+    return this.rollup.read.getManaLimit();
+  }
+
+  @memoize
+  getVersion() {
+    return this.rollup.read.getVersion();
+  }
+
+  @memoize
+  async getGenesisArchiveTreeRoot(): Promise<`0x${string}`> {
+    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,
+      epochDuration: Number(epochDuration),
+      proofSubmissionEpochs: Number(proofSubmissionEpochs),
+    };
+  }
+
+  getSlasherAddress() {
+    return this.rollup.read.getSlasher();
+  }
+
+  /**
+   * Returns a SlasherContract instance for interacting with the slasher contract.
+   */
+  async getSlasherContract(): Promise<SlasherContract | undefined> {
+    const slasherAddress = EthAddress.fromString(await this.getSlasherAddress());
+    if (slasherAddress.isZero()) {
+      return undefined;
+    }
+    return new SlasherContract(this.client, slasherAddress);
+  }
+
+  getOwner() {
+    return this.rollup.read.owner();
+  }
+
+  getActiveAttesterCount() {
+    return this.rollup.read.getActiveAttesterCount();
   }
 
   public async getSlashingProposerAddress() {
-    const slasherAddress = await this.rollup.read.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();
+  }
+
+  getCheckpointReward() {
+    return this.rollup.read.getCheckpointReward();
+  }
+
+  async getCheckpointNumber(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber());
+  }
+
+  async getProvenCheckpointNumber(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber());
   }
 
-  getBlockNumber() {
-    return this.rollup.read.getPendingBlockNumber();
+  async getSlotNumber(): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
   }
 
-  getProvenBlockNumber() {
-    return this.rollup.read.getProvenBlockNumber();
+  getL1FeesAt(timestamp: bigint) {
+    return this.rollup.read.getL1FeesAt([timestamp]);
   }
 
-  getSlotNumber() {
-    return this.rollup.read.getCurrentSlot();
+  getFeeAssetPerEth() {
+    return this.rollup.read.getFeeAssetPerEth();
   }
 
-  getCommitteeAt(timestamp: bigint) {
-    return this.rollup.read.getCommitteeAt([timestamp]);
+  async getCommitteeAt(timestamp: bigint): Promise<readonly `0x${string}`[] | undefined> {
+    const { result } = await this.client
+      .simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'getCommitteeAt',
+        args: [timestamp],
+      })
+      .catch(e => {
+        if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+          return { result: undefined };
+        }
+        throw e;
+      });
+
+    return result;
   }
 
   getSampleSeedAt(timestamp: bigint) {
@@ -148,33 +373,99 @@ export class RollupContract {
     return this.rollup.read.getCurrentSampleSeed();
   }
 
-  getCurrentEpochCommittee() {
-    return this.rollup.read.getCurrentEpochCommittee();
+  async getCurrentEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
   }
 
-  getCurrentProposer() {
-    return this.rollup.read.getCurrentProposer();
+  async getCurrentEpochCommittee(): Promise<readonly `0x${string}`[] | undefined> {
+    const { result } = await this.client
+      .simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'getCurrentEpochCommittee',
+        args: [],
+      })
+      .catch(e => {
+        if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+          return { result: undefined };
+        }
+        throw e;
+      });
+
+    return result;
   }
 
-  getProposerAt(timestamp: bigint) {
-    return this.rollup.read.getProposerAt([timestamp]);
+  async getCurrentProposer() {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getCurrentProposer',
+      args: [],
+    });
+
+    return result;
   }
 
-  getBlock(blockNumber: bigint) {
-    return this.rollup.read.getBlock([blockNumber]);
+  async getProposerAt(timestamp: bigint) {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getProposerAt',
+      args: [timestamp],
+    });
+
+    return result;
   }
 
-  getTips() {
-    return this.rollup.read.getTips();
+  getCheckpoint(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
   }
 
-  getTimestampForSlot(slot: bigint) {
-    return this.rollup.read.getTimestampForSlot([slot]);
+  /** Returns the pending checkpoint from the rollup contract */
+  getPendingCheckpoint() {
+    // We retry because of race conditions during prunes: we may get a pending checkpoint number which is immediately
+    // reorged out due to a prune happening, causing the subsequent getCheckpoint call to fail. So we try again in that case.
+    return retry(
+      async () => {
+        const pendingCheckpointNumber = await this.getCheckpointNumber();
+        const pendingCheckpoint = await this.getCheckpoint(pendingCheckpointNumber);
+        return pendingCheckpoint;
+      },
+      'getting pending checkpoint',
+      makeBackoff([0.5, 0.5, 0.5]),
+    );
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
-    return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
+  async getTips(): Promise<{ pending: CheckpointNumber; proven: CheckpointNumber }> {
+    const { pending, proven } = await this.rollup.read.getTips();
+    return {
+      pending: CheckpointNumber.fromBigInt(pending),
+      proven: CheckpointNumber.fromBigInt(proven),
+    };
+  }
+
+  getTimestampForSlot(slot: SlotNumber) {
+    return this.rollup.read.getTimestampForSlot([BigInt(slot)]);
+  }
+
+  getEntryQueueLength() {
+    return this.rollup.read.getEntryQueueLength();
+  }
+
+  getAvailableValidatorFlushes() {
+    return this.rollup.read.getAvailableValidatorFlushes();
+  }
+
+  async getNextFlushableEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getNextFlushableEpoch());
+  }
+
+  async getCurrentEpochNumber(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
+  }
+
+  async getEpochNumberForCheckpoint(checkpointNumber: CheckpointNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochForCheckpoint([BigInt(checkpointNumber)]));
   }
 
   async getRollupAddresses(): Promise<L1RollupContractAddresses> {
@@ -185,6 +476,7 @@ export class RollupContract {
       rewardDistributorAddress,
       feeJuiceAddress,
       stakingAssetAddress,
+      gseAddress,
     ] = (
       await Promise.all([
         this.rollup.read.getInbox(),
@@ -193,6 +485,7 @@ export class RollupContract {
         this.rollup.read.getRewardDistributor(),
         this.rollup.read.getFeeAsset(),
         this.rollup.read.getStakingAsset(),
+        this.rollup.read.getGSE(),
       ] as const)
     ).map(EthAddress.fromString);
 
@@ -204,25 +497,31 @@ export class RollupContract {
       feeJuiceAddress,
       stakingAssetAddress,
       rewardDistributorAddress,
+      gseAddress,
     };
   }
 
-  public async getEpochNumberForSlotNumber(slotNumber: bigint): Promise<bigint> {
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+  public async getFeeJuicePortal() {
+    return EthAddress.fromString(await this.rollup.read.getFeeAssetPortal());
+  }
+
+  public async getEpochNumberForSlotNumber(slotNumber: SlotNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([BigInt(slotNumber)]));
   }
 
   getEpochProofPublicInputs(
-    args: readonly [bigint, bigint, EpochProofPublicInputArgs, readonly `0x${string}`[], `0x${string}`, `0x${string}`],
+    args: readonly [bigint, bigint, EpochProofPublicInputArgs, readonly `0x${string}`[], `0x${string}`],
   ) {
     return this.rollup.read.getEpochProofPublicInputs(args);
   }
 
   public async validateHeader(
     args: readonly [
+      ViemHeader,
+      ViemCommitteeAttestations,
+      `0x${string}`[],
+      ViemSignature,
       `0x${string}`,
-      ViemSignature[],
-      `0x${string}`,
-      bigint,
       `0x${string}`,
       {
         ignoreDA: boolean;
@@ -232,7 +531,13 @@ export class RollupContract {
     account: `0x${string}` | Account,
   ): Promise<void> {
     try {
-      await this.rollup.read.validateHeader(args, { account });
+      await this.client.simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'validateHeaderWithAttestations',
+        args,
+        account,
+      });
     } catch (error: unknown) {
       throw formatViemError(error);
     }
@@ -244,31 +549,272 @@ export class RollupContract {
    * @dev     Throws if unable to propose
    *
    * @param archive - The archive that we expect to be current state
-   * @return [slot, blockNumber] - If you can propose, the L2 slot number and L2 block number of the next Ethereum block,
+   * @return [slot, checkpointNumber, timeOfNextL1Slot] - If you can propose, the L2 slot number, checkpoint number and
+   * timestamp of the next L1 block
    * @throws otherwise
    */
   public async canProposeAtNextEthBlock(
     archive: Buffer,
     account: `0x${string}` | Account,
-    slotDuration: bigint | number,
-  ): Promise<[bigint, bigint]> {
-    if (typeof slotDuration === 'number') {
-      slotDuration = BigInt(slotDuration);
-    }
-    const timeOfNextL1Slot = (await this.client.getBlock()).timestamp + slotDuration;
+    slotDuration: number,
+    opts: { forcePendingCheckpointNumber?: CheckpointNumber } = {},
+  ): Promise<{ slot: SlotNumber; checkpointNumber: CheckpointNumber; timeOfNextL1Slot: bigint }> {
+    const latestBlock = await this.client.getBlock();
+    const timeOfNextL1Slot = latestBlock.timestamp + BigInt(slotDuration);
+    const who = typeof account === 'string' ? account : account.address;
+
     try {
-      const [slot, blockNumber] = await this.rollup.read.canProposeAtTime(
-        [timeOfNextL1Slot, `0x${archive.toString('hex')}`],
-        { account },
-      );
-      return [slot, blockNumber];
+      const {
+        result: [slot, checkpointNumber],
+      } = await this.client.simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'canProposeAtTime',
+        args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`, who],
+        account,
+        stateOverride: await this.makePendingCheckpointNumberOverride(opts.forcePendingCheckpointNumber),
+      });
+
+      return {
+        slot: SlotNumber.fromBigInt(slot),
+        checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber),
+        timeOfNextL1Slot,
+      };
     } catch (err: unknown) {
       throw formatViemError(err);
     }
   }
 
+  /**
+   * Returns a state override that sets the pending checkpoint number to the specified value. Useful for simulations.
+   * Requires querying the current state of the contract to get the current proven checkpoint number, as they are both
+   * stored in the same slot. If the argument is undefined, it returns an empty override.
+   */
+  public async makePendingCheckpointNumberOverride(
+    forcePendingCheckpointNumber: CheckpointNumber | undefined,
+  ): Promise<StateOverride> {
+    if (forcePendingCheckpointNumber === undefined) {
+      return [];
+    }
+    const slot = RollupContract.stfStorageSlot;
+    const currentValue = await this.client.getStorageAt({ address: this.address, slot });
+    const currentProvenCheckpointNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
+    const newValue = (BigInt(forcePendingCheckpointNumber) << 128n) | currentProvenCheckpointNumber;
+    return [
+      {
+        address: this.address,
+        stateDiff: [{ slot, value: `0x${newValue.toString(16).padStart(64, '0')}` }],
+      },
+    ];
+  }
+
+  /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
+  public buildInvalidateBadAttestationRequest(
+    checkpointNumber: CheckpointNumber,
+    attestationsAndSigners: ViemCommitteeAttestations,
+    committee: EthAddress[],
+    invalidIndex: number,
+  ): L1TxRequest {
+    return {
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'invalidateBadAttestation',
+        args: [
+          BigInt(checkpointNumber),
+          attestationsAndSigners,
+          committee.map(addr => addr.toString()),
+          BigInt(invalidIndex),
+        ],
+      }),
+    };
+  }
+
+  /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
+  public buildInvalidateInsufficientAttestationsRequest(
+    checkpointNumber: CheckpointNumber,
+    attestationsAndSigners: ViemCommitteeAttestations,
+    committee: EthAddress[],
+  ): L1TxRequest {
+    return {
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'invalidateInsufficientAttestations',
+        args: [BigInt(checkpointNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
+      }),
+    };
+  }
+
   /** Calls getHasSubmitted directly. Returns whether the given prover has submitted a proof with the given length for the given epoch. */
-  public getHasSubmittedProof(epochNumber: number, numberOfBlocksInEpoch: number, prover: EthAddress) {
-    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover.toString()]);
+  public getHasSubmittedProof(epochNumber: EpochNumber, numberOfCheckpointsInEpoch: number, prover: Hex | EthAddress) {
+    if (prover instanceof EthAddress) {
+      prover = prover.toString();
+    }
+    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfCheckpointsInEpoch), prover]);
+  }
+
+  getManaBaseFeeAt(timestamp: bigint, inFeeAsset: boolean) {
+    return this.rollup.read.getManaBaseFeeAt([timestamp, inFeeAsset]);
+  }
+
+  async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
+  }
+
+  async status(checkpointNumber: CheckpointNumber, options?: { blockNumber?: bigint }) {
+    await checkBlockTag(options?.blockNumber, this.client);
+    return this.rollup.read.status([BigInt(checkpointNumber)], options);
+  }
+
+  async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
+    await checkBlockTag(options?.blockNumber, this.client);
+    return this.rollup.read.canPruneAtTime([timestamp], options);
+  }
+
+  archive() {
+    return this.rollup.read.archive();
+  }
+
+  archiveAt(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.archiveAt([BigInt(checkpointNumber)]);
+  }
+
+  getSequencerRewards(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getSequencerRewards([address]);
+  }
+
+  getSpecificProverRewardsForEpoch(epoch: bigint, prover: Hex | EthAddress) {
+    if (prover instanceof EthAddress) {
+      prover = prover.toString();
+    }
+    return this.rollup.read.getSpecificProverRewardsForEpoch([epoch, prover]);
+  }
+
+  async getAttesters() {
+    const attesterSize = await this.getActiveAttesterCount();
+    const gse = new GSEContract(this.client, await this.getGSE());
+    const ts = (await this.client.getBlock()).timestamp;
+
+    const indices = Array.from({ length: Number(attesterSize) }, (_, i) => BigInt(i));
+    const chunks = chunk(indices, 1000);
+
+    return (await Promise.all(chunks.map(chunk => gse.getAttestersFromIndicesAtTime(this.address, ts, chunk)))).flat();
+  }
+
+  getAttesterView(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getAttesterView([address]);
+  }
+
+  getStatus(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getStatus([address]);
+  }
+
+  getBlobCommitmentsHash(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getBlobCommitmentsHash([BigInt(checkpointNumber)]);
+  }
+
+  getCurrentBlobCommitmentsHash() {
+    return this.rollup.read.getCurrentBlobCommitmentsHash();
+  }
+
+  getStakingAsset() {
+    return this.rollup.read.getStakingAsset();
+  }
+
+  getRewardConfig() {
+    return this.rollup.read.getRewardConfig();
+  }
+
+  setupEpoch(l1TxUtils: L1TxUtils) {
+    return l1TxUtils.sendAndMonitorTransaction({
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'setupEpoch',
+        args: [],
+      }),
+    });
+  }
+
+  vote(l1TxUtils: L1TxUtils, proposalId: bigint) {
+    return l1TxUtils.sendAndMonitorTransaction({
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'vote',
+        args: [proposalId],
+      }),
+    });
+  }
+
+  public listenToSlasherChanged(
+    callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown,
+  ): WatchContractEventReturnType {
+    return this.rollup.watchEvent.SlasherUpdated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.oldSlasher && args.newSlasher) {
+              callback(args as { oldSlasher: `0x${string}`; newSlasher: `0x${string}` });
+            }
+          }
+        },
+      },
+    );
+  }
+
+  public listenToCheckpointInvalidated(
+    callback: (args: { checkpointNumber: CheckpointNumber }) => unknown,
+  ): WatchContractEventReturnType {
+    return this.rollup.watchEvent.CheckpointInvalidated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.checkpointNumber !== undefined) {
+              callback({ checkpointNumber: CheckpointNumber.fromBigInt(args.checkpointNumber) });
+            }
+          }
+        },
+      },
+    );
+  }
+
+  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 => ({
+      amount: event.args.amount!,
+      attester: EthAddress.fromString(event.args.attester!),
+    }));
+  }
+
+  public listenToSlash(
+    callback: (args: { amount: bigint; attester: EthAddress }) => unknown,
+  ): WatchContractEventReturnType {
+    return this.rollup.watchEvent.Slashed(
+      {},
+      {
+        strict: true,
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            callback({ amount: args.amount!, attester: EthAddress.fromString(args.attester!) });
+          }
+        },
+      },
+    );
   }
 }