@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/contracts/rollup.ts

@@ -1,6 +1,11 @@
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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';
 
@@ -18,7 +23,7 @@ import {
 } 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 { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
@@ -26,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';
@@ -56,12 +62,16 @@ export type L1RollupContractAddresses = Pick<
 export type EpochProofPublicInputArgs = {
   previousArchive: `0x${string}`;
   endArchive: `0x${string}`;
+  outHash: `0x${string}`;
   proverId: `0x${string}`;
 };
 
 export type ViemHeader = {
   lastArchiveRoot: `0x${string}`;
-  contentCommitment: ViemContentCommitment;
+  blockHeadersHash: `0x${string}`;
+  blobsHash: `0x${string}`;
+  inHash: `0x${string}`;
+  outHash: `0x${string}`;
   slotNumber: bigint;
   timestamp: bigint;
   coinbase: `0x${string}`;
@@ -70,43 +80,144 @@ export type ViemHeader = {
   totalManaUsed: bigint;
 };
 
-export type ViemContentCommitment = {
-  blobsHash: `0x${string}`;
-  inHash: `0x${string}`;
-  outHash: `0x${string}`;
-};
-
 export type ViemGasFees = {
   feePerDaGas: bigint;
   feePerL2Gas: bigint;
 };
 
-export type ViemStateReference = {
-  l1ToL2MessageTree: ViemAppendOnlyTreeSnapshot;
-  partialStateReference: ViemPartialStateReference;
+export enum SlashingProposerType {
+  None = 0,
+  Tally = 1,
+  Empire = 2,
+}
+
+/**
+ * Status of a validator/attester in the staking system.
+ * Matches the Status enum in StakingLib.sol
+ */
+export enum AttesterStatus {
+  NONE = 0,
+  VALIDATING = 1,
+  ZOMBIE = 2,
+  EXITING = 3,
+}
+
+/**
+ * Fee header data for a checkpoint
+ */
+export type FeeHeader = {
+  excessMana: bigint;
+  manaUsed: bigint;
+  ethPerFeeAsset: bigint;
+  congestionCost: bigint;
+  proverCost: bigint;
+};
+
+/**
+ * Checkpoint log data returned from the rollup contract
+ */
+export type CheckpointLog = {
+  archive: Fr;
+  headerHash: Buffer32;
+  blobCommitmentsHash: Buffer32;
+  attestationsHash: Buffer32;
+  payloadDigest: Buffer32;
+  slotNumber: SlotNumber;
+  feeHeader: FeeHeader;
 };
 
-export type ViemPartialStateReference = {
-  noteHashTree: ViemAppendOnlyTreeSnapshot;
-  nullifierTree: ViemAppendOnlyTreeSnapshot;
-  publicDataTree: ViemAppendOnlyTreeSnapshot;
+/**
+ * L1 fee data (base fee and blob fee)
+ */
+export type L1FeeData = {
+  baseFee: bigint;
+  blobFee: bigint;
 };
 
-export type ViemAppendOnlyTreeSnapshot = {
-  root: `0x${string}`;
-  nextAvailableLeafIndex: number;
+/** Components of the minimum fee per mana, as returned by the L1 rollup contract. */
+export type ManaMinFeeComponents = {
+  sequencerCost: bigint;
+  proverCost: bigint;
+  congestionCost: bigint;
+  congestionMultiplier: bigint;
 };
 
-export enum SlashingProposerType {
-  None = 0,
-  Tally = 1,
-  Empire = 2,
-}
+/**
+ * Reward configuration for the rollup
+ */
+export type RewardConfig = {
+  rewardDistributor: EthAddress;
+  sequencerBps: bigint;
+  booster: EthAddress;
+  checkpointReward: bigint;
+};
+
+/**
+ * Exit information for a validator
+ */
+export type Exit = {
+  withdrawalId: bigint;
+  amount: bigint;
+  exitableAt: bigint;
+  recipientOrWithdrawer: EthAddress;
+  isRecipient: boolean;
+  exists: boolean;
+};
+
+/**
+ * Attester configuration including public key and withdrawer
+ */
+export type AttesterConfig = {
+  publicKey: {
+    x: bigint;
+    y: bigint;
+  };
+  withdrawer: EthAddress;
+};
+
+/**
+ * Complete view of an attester's state
+ */
+export type AttesterView = {
+  status: AttesterStatus;
+  effectiveBalance: bigint;
+  exit: Exit;
+  config: AttesterConfig;
+};
+
+/**
+ * Return for a status call
+ */
+export type RollupStatusResponse = {
+  provenCheckpointNumber: CheckpointNumber;
+  provenArchive: Fr;
+  pendingCheckpointNumber: CheckpointNumber;
+  pendingArchive: Fr;
+  archiveOfMyCheckpoint: Fr;
+};
+
+/** Arguments for the CheckpointProposed event. */
+export type CheckpointProposedArgs = {
+  checkpointNumber: CheckpointNumber;
+  archive: Fr;
+  versionedBlobHashes: Buffer[];
+  /** Hash of attestations emitted in the CheckpointProposed event. */
+  attestationsHash: Buffer32;
+  /** Digest of the payload emitted in the CheckpointProposed event. */
+  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;
@@ -120,7 +231,7 @@ export class RollupContract {
     return (RollupContract.cachedStfStorageSlot ??= keccak256(Buffer.from('aztec.stf.storage', 'utf-8')));
   }
 
-  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1ContractsReturnType) {
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployAztecL1ContractsReturnType) {
     const {
       l1Client,
       l1ContractAddresses: { rollupAddress },
@@ -144,8 +255,8 @@ export class RollupContract {
     this.rollup = getContract({ address, abi: RollupAbi, client });
   }
 
-  getGSE() {
-    return this.rollup.read.getGSE();
+  async getGSE(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.rollup.read.getGSE());
   }
 
   public get address() {
@@ -187,88 +298,107 @@ export class RollupContract {
   }
 
   @memoize
-  getL1StartBlock() {
+  getL1StartBlock(): Promise<bigint> {
     return this.rollup.read.L1_BLOCK_AT_GENESIS();
   }
 
   @memoize
-  getL1GenesisTime() {
+  getL1GenesisTime(): Promise<bigint> {
     return this.rollup.read.getGenesisTime();
   }
 
   @memoize
-  getProofSubmissionEpochs() {
-    return this.rollup.read.getProofSubmissionEpochs();
+  async getProofSubmissionEpochs(): Promise<number> {
+    return Number(await this.rollup.read.getProofSubmissionEpochs());
   }
 
   @memoize
-  getEpochDuration() {
-    return this.rollup.read.getEpochDuration();
+  async getEpochDuration(): Promise<number> {
+    return Number(await this.rollup.read.getEpochDuration());
   }
 
   @memoize
-  getSlotDuration() {
-    return this.rollup.read.getSlotDuration();
+  async getSlotDuration(): Promise<number> {
+    return Number(await this.rollup.read.getSlotDuration());
   }
 
   @memoize
-  getTargetCommitteeSize() {
-    return this.rollup.read.getTargetCommitteeSize();
+  async getTargetCommitteeSize(): Promise<number> {
+    return Number(await this.rollup.read.getTargetCommitteeSize());
   }
 
   @memoize
-  getEjectionThreshold() {
+  getEjectionThreshold(): Promise<bigint> {
     return this.rollup.read.getEjectionThreshold();
   }
 
   @memoize
-  getLocalEjectionThreshold() {
+  getLocalEjectionThreshold(): Promise<bigint> {
     return this.rollup.read.getLocalEjectionThreshold();
   }
 
   @memoize
-  getLagInEpochs() {
-    return this.rollup.read.getLagInEpochs();
+  async getLagInEpochsForValidatorSet(): Promise<number> {
+    return Number(await this.rollup.read.getLagInEpochsForValidatorSet());
+  }
+
+  @memoize
+  async getLagInEpochsForRandao(): Promise<number> {
+    return Number(await this.rollup.read.getLagInEpochsForRandao());
   }
 
   @memoize
-  getActivationThreshold() {
+  getActivationThreshold(): Promise<bigint> {
     return this.rollup.read.getActivationThreshold();
   }
 
   @memoize
-  getExitDelay() {
-    return this.rollup.read.getExitDelay();
+  async getExitDelay(): Promise<number> {
+    return Number(await this.rollup.read.getExitDelay());
   }
 
   @memoize
-  getManaTarget() {
+  getManaTarget(): Promise<bigint> {
     return this.rollup.read.getManaTarget();
   }
 
   @memoize
-  getProvingCostPerMana() {
+  getProvingCostPerMana(): Promise<bigint> {
     return this.rollup.read.getProvingCostPerManaInEth();
   }
 
   @memoize
-  getProvingCostPerManaInFeeAsset() {
+  getProvingCostPerManaInFeeAsset(): Promise<bigint> {
     return this.rollup.read.getProvingCostPerManaInFeeAsset();
   }
 
   @memoize
-  getManaLimit() {
+  getManaLimit(): Promise<bigint> {
     return this.rollup.read.getManaLimit();
   }
 
   @memoize
-  getVersion() {
+  getVersion(): Promise<bigint> {
     return this.rollup.read.getVersion();
   }
 
   @memoize
-  async getGenesisArchiveTreeRoot(): Promise<`0x${string}`> {
-    return await this.rollup.read.archiveAt([0n]);
+  async getGenesisArchiveTreeRoot(): Promise<Fr> {
+    return Fr.fromString(await this.rollup.read.archiveAt([0n]));
+  }
+
+  @memoize
+  async getVkTreeRoot(): Promise<Fr> {
+    const slot = BigInt(RollupContract.stfStorageSlot) + 3n;
+    const value = await this.client.getStorageAt({ address: this.address, slot: `0x${slot.toString(16)}` });
+    return Fr.fromString(value ?? '0x0');
+  }
+
+  @memoize
+  async getProtocolContractsHash(): Promise<Fr> {
+    const slot = BigInt(RollupContract.stfStorageSlot) + 4n;
+    const value = await this.client.getStorageAt({ address: this.address, slot: `0x${slot.toString(16)}` });
+    return Fr.fromString(value ?? '0x0');
   }
 
   /**
@@ -283,44 +413,110 @@ export class RollupContract {
     slotDuration: number;
     epochDuration: number;
     proofSubmissionEpochs: number;
+    targetCommitteeSize: number;
+    rollupManaLimit: number;
   }> {
-    const [l1StartBlock, l1GenesisTime, slotDuration, epochDuration, proofSubmissionEpochs] = await Promise.all([
+    const [
+      l1StartBlock,
+      l1GenesisTime,
+      slotDuration,
+      epochDuration,
+      proofSubmissionEpochs,
+      targetCommitteeSize,
+      rollupManaLimit,
+    ] = await Promise.all([
       this.getL1StartBlock(),
       this.getL1GenesisTime(),
       this.getSlotDuration(),
       this.getEpochDuration(),
       this.getProofSubmissionEpochs(),
+      this.getTargetCommitteeSize(),
+      this.getManaLimit(),
     ]);
     return {
       l1StartBlock,
       l1GenesisTime,
-      slotDuration: Number(slotDuration),
+      slotDuration,
       epochDuration: Number(epochDuration),
       proofSubmissionEpochs: Number(proofSubmissionEpochs),
+      targetCommitteeSize,
+      rollupManaLimit: Number(rollupManaLimit),
     };
   }
 
-  getSlasherAddress() {
-    return this.rollup.read.getSlasher();
+  async getSlasherAddress(): Promise<EthAddress> {
+    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.
    */
   async getSlasherContract(): Promise<SlasherContract | undefined> {
-    const slasherAddress = EthAddress.fromString(await this.getSlasherAddress());
+    const slasherAddress = await this.getSlasherAddress();
     if (slasherAddress.isZero()) {
       return undefined;
     }
     return new SlasherContract(this.client, slasherAddress);
   }
 
-  getOwner() {
-    return this.rollup.read.owner();
+  async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.rollup.read.owner());
   }
 
-  getActiveAttesterCount() {
-    return this.rollup.read.getActiveAttesterCount();
+  async getActiveAttesterCount(): Promise<number> {
+    return Number(await this.rollup.read.getActiveAttesterCount());
   }
 
   public async getSlashingProposerAddress() {
@@ -331,31 +527,36 @@ export class RollupContract {
     return await slasher.getProposer();
   }
 
-  getBlockReward() {
-    return this.rollup.read.getBlockReward();
+  getCheckpointReward(): Promise<bigint> {
+    return this.rollup.read.getCheckpointReward();
   }
 
-  getBlockNumber() {
-    return this.rollup.read.getPendingBlockNumber();
+  async getCheckpointNumber(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber());
   }
 
-  getProvenBlockNumber() {
-    return this.rollup.read.getProvenBlockNumber();
+  async getProvenCheckpointNumber(options?: { blockNumber?: bigint }): Promise<CheckpointNumber> {
+    await checkBlockTag(options?.blockNumber, this.client);
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber(options));
   }
 
-  getSlotNumber() {
-    return this.rollup.read.getCurrentSlot();
+  async getSlotNumber(): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
   }
 
-  getL1FeesAt(timestamp: bigint) {
-    return this.rollup.read.getL1FeesAt([timestamp]);
+  async getL1FeesAt(timestamp: bigint): Promise<L1FeeData> {
+    const result = await this.rollup.read.getL1FeesAt([timestamp]);
+    return {
+      baseFee: result.baseFee,
+      blobFee: result.blobFee,
+    };
   }
 
-  getFeeAssetPerEth() {
-    return this.rollup.read.getFeeAssetPerEth();
+  getEthPerFeeAsset(): Promise<bigint> {
+    return this.rollup.read.getEthPerFeeAsset();
   }
 
-  async getCommitteeAt(timestamp: bigint): Promise<readonly `0x${string}`[] | undefined> {
+  async getCommitteeAt(timestamp: bigint): Promise<EthAddress[] | undefined> {
     const { result } = await this.client
       .simulateContract({
         address: this.address,
@@ -370,22 +571,22 @@ export class RollupContract {
         throw e;
       });
 
-    return result;
+    return result ? result.map(addr => EthAddress.fromString(addr)) : undefined;
   }
 
-  getSampleSeedAt(timestamp: bigint) {
-    return this.rollup.read.getSampleSeedAt([timestamp]);
+  async getSampleSeedAt(timestamp: bigint): Promise<Buffer32> {
+    return Buffer32.fromBigInt(await this.rollup.read.getSampleSeedAt([timestamp]));
   }
 
-  getCurrentSampleSeed() {
-    return this.rollup.read.getCurrentSampleSeed();
+  async getCurrentSampleSeed(): Promise<Buffer32> {
+    return Buffer32.fromBigInt(await this.rollup.read.getCurrentSampleSeed());
   }
 
-  getCurrentEpoch() {
-    return this.rollup.read.getCurrentEpoch();
+  async getCurrentEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
   }
 
-  async getCurrentEpochCommittee(): Promise<readonly `0x${string}`[] | undefined> {
+  async getCurrentEpochCommittee(): Promise<EthAddress[] | undefined> {
     const { result } = await this.client
       .simulateContract({
         address: this.address,
@@ -400,10 +601,10 @@ export class RollupContract {
         throw e;
       });
 
-    return result;
+    return result ? result.map(addr => EthAddress.fromString(addr)) : undefined;
   }
 
-  async getCurrentProposer() {
+  async getCurrentProposer(): Promise<EthAddress> {
     const { result } = await this.client.simulateContract({
       address: this.address,
       abi: RollupAbi,
@@ -411,10 +612,10 @@ export class RollupContract {
       args: [],
     });
 
-    return result;
+    return EthAddress.fromString(result);
   }
 
-  async getProposerAt(timestamp: bigint) {
+  async getProposerAt(timestamp: bigint): Promise<EthAddress> {
     const { result } = await this.client.simulateContract({
       address: this.address,
       abi: RollupAbi,
@@ -422,39 +623,73 @@ export class RollupContract {
       args: [timestamp],
     });
 
-    return result;
+    return EthAddress.fromString(result);
   }
 
-  getBlock(blockNumber: bigint | number) {
-    return this.rollup.read.getBlock([BigInt(blockNumber)]);
+  async getCheckpoint(checkpointNumber: CheckpointNumber): Promise<CheckpointLog> {
+    const result = await this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
+    return {
+      archive: Fr.fromString(result.archive),
+      headerHash: Buffer32.fromString(result.headerHash),
+      blobCommitmentsHash: Buffer32.fromString(result.blobCommitmentsHash),
+      attestationsHash: Buffer32.fromString(result.attestationsHash),
+      payloadDigest: Buffer32.fromString(result.payloadDigest),
+      slotNumber: SlotNumber.fromBigInt(result.slotNumber),
+      feeHeader: {
+        excessMana: result.feeHeader.excessMana,
+        manaUsed: result.feeHeader.manaUsed,
+        ethPerFeeAsset: result.feeHeader.ethPerFeeAsset,
+        congestionCost: result.feeHeader.congestionCost,
+        proverCost: result.feeHeader.proverCost,
+      },
+    };
+  }
+
+  /** 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]),
+    );
   }
 
-  getTips() {
-    return this.rollup.read.getTips();
+  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: bigint) {
-    return this.rollup.read.getTimestampForSlot([slot]);
+  getTimestampForSlot(slot: SlotNumber): Promise<bigint> {
+    return this.rollup.read.getTimestampForSlot([BigInt(slot)]);
   }
 
-  getEntryQueueLength() {
-    return this.rollup.read.getEntryQueueLength();
+  async getEntryQueueLength(): Promise<number> {
+    return Number(await this.rollup.read.getEntryQueueLength());
   }
 
-  getAvailableValidatorFlushes() {
-    return this.rollup.read.getAvailableValidatorFlushes();
+  async getAvailableValidatorFlushes(): Promise<number> {
+    return Number(await this.rollup.read.getAvailableValidatorFlushes());
   }
 
-  getNextFlushableEpoch() {
-    return this.rollup.read.getNextFlushableEpoch();
+  async getNextFlushableEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getNextFlushableEpoch());
   }
 
-  getCurrentEpochNumber(): Promise<bigint> {
-    return this.rollup.read.getCurrentEpoch();
+  async getCurrentEpochNumber(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
   }
 
-  getEpochNumberForBlock(blockNumber: bigint) {
-    return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
+  async getEpochNumberForCheckpoint(checkpointNumber: CheckpointNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochForCheckpoint([BigInt(checkpointNumber)]));
   }
 
   async getRollupAddresses(): Promise<L1RollupContractAddresses> {
@@ -494,14 +729,15 @@ export class RollupContract {
     return EthAddress.fromString(await this.rollup.read.getFeeAssetPortal());
   }
 
-  public async getEpochNumberForSlotNumber(slotNumber: bigint): Promise<bigint> {
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+  public async getEpochNumberForSlotNumber(slotNumber: SlotNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([BigInt(slotNumber)]));
   }
 
-  getEpochProofPublicInputs(
+  async getEpochProofPublicInputs(
     args: readonly [bigint, bigint, EpochProofPublicInputArgs, readonly `0x${string}`[], `0x${string}`],
-  ) {
-    return this.rollup.read.getEpochProofPublicInputs(args);
+  ): Promise<Fr[]> {
+    const result = await this.rollup.read.getEpochProofPublicInputs(args);
+    return result.map(Fr.fromString);
   }
 
   public async validateHeader(
@@ -538,53 +774,58 @@ 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(
+  public async canProposeAt(
     archive: Buffer,
     account: `0x${string}` | Account,
-    slotDuration: bigint | number,
-    opts: { forcePendingBlockNumber?: number } = {},
-  ): Promise<{ slot: bigint; blockNumber: bigint; timeOfNextL1Slot: bigint }> {
-    if (typeof slotDuration === 'number') {
-      slotDuration = BigInt(slotDuration);
-    }
+    slotDuration: bigint,
+    slotOffset: bigint,
+    opts: { forcePendingCheckpointNumber?: CheckpointNumber } = {},
+  ): Promise<{ slot: SlotNumber; checkpointNumber: CheckpointNumber; timeOfNextL1Slot: bigint }> {
     const latestBlock = await this.client.getBlock();
-    const timeOfNextL1Slot = latestBlock.timestamp + slotDuration;
+    const timeOfNextL1Slot = latestBlock.timestamp + slotDuration + slotOffset;
     const who = typeof account === 'string' ? account : account.address;
 
     try {
       const {
-        result: [slot, blockNumber],
+        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.makePendingBlockNumberOverride(opts.forcePendingBlockNumber),
+        stateOverride: await this.makePendingCheckpointNumberOverride(opts.forcePendingCheckpointNumber),
       });
 
-      return { slot, blockNumber, timeOfNextL1Slot };
+      return {
+        slot: SlotNumber.fromBigInt(slot),
+        checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber),
+        timeOfNextL1Slot,
+      };
     } catch (err: unknown) {
       throw formatViemError(err);
     }
   }
 
   /**
-   * Returns a state override that sets the pending block number to the specified value. Useful for simulations.
-   * Requires querying the current state of the contract to get the current proven block number, as they are both
+   * 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 makePendingBlockNumberOverride(forcePendingBlockNumber: number | undefined): Promise<StateOverride> {
-    if (forcePendingBlockNumber === undefined) {
+  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 currentProvenBlockNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
-    const newValue = (BigInt(forcePendingBlockNumber) << 128n) | currentProvenBlockNumber;
+    const currentProvenCheckpointNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
+    const newValue = (BigInt(forcePendingCheckpointNumber) << 128n) | currentProvenCheckpointNumber;
     return [
       {
         address: this.address,
@@ -595,18 +836,19 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
   public buildInvalidateBadAttestationRequest(
-    blockNumber: number,
+    checkpointNumber: CheckpointNumber,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
     invalidIndex: number,
   ): L1TxRequest {
     return {
       to: this.address,
+      abi: RollupAbi,
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateBadAttestation',
         args: [
-          BigInt(blockNumber),
+          BigInt(checkpointNumber),
           attestationsAndSigners,
           committee.map(addr => addr.toString()),
           BigInt(invalidIndex),
@@ -617,112 +859,157 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
   public buildInvalidateInsufficientAttestationsRequest(
-    blockNumber: number,
+    checkpointNumber: CheckpointNumber,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
   ): L1TxRequest {
     return {
       to: this.address,
+      abi: RollupAbi,
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateInsufficientAttestations',
-        args: [BigInt(blockNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
+        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: Hex | EthAddress) {
+  public getHasSubmittedProof(epochNumber: EpochNumber, numberOfCheckpointsInEpoch: number, prover: Hex | EthAddress) {
     if (prover instanceof EthAddress) {
       prover = prover.toString();
     }
-    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover]);
+    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfCheckpointsInEpoch), prover]);
   }
 
-  getManaBaseFeeAt(timestamp: bigint, inFeeAsset: boolean) {
-    return this.rollup.read.getManaBaseFeeAt([timestamp, inFeeAsset]);
+  getManaMinFeeAt(timestamp: bigint, inFeeAsset: boolean): Promise<bigint> {
+    return this.rollup.read.getManaMinFeeAt([timestamp, inFeeAsset]);
   }
 
-  getSlotAt(timestamp: bigint) {
-    return this.rollup.read.getSlotAt([timestamp]);
+  async getManaMinFeeComponentsAt(timestamp: bigint, inFeeAsset: boolean): Promise<ManaMinFeeComponents> {
+    const result = await this.rollup.read.getManaMinFeeComponentsAt([timestamp, inFeeAsset]);
+    return {
+      sequencerCost: result.sequencerCost,
+      proverCost: result.proverCost,
+      congestionCost: result.congestionCost,
+      congestionMultiplier: result.congestionMultiplier,
+    };
   }
 
-  async status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+  async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
+  }
+
+  async status(checkpointNumber: CheckpointNumber, options?: { blockNumber?: bigint }): Promise<RollupStatusResponse> {
     await checkBlockTag(options?.blockNumber, this.client);
-    return this.rollup.read.status([blockNumber], options);
+    const result = await this.rollup.read.status([BigInt(checkpointNumber)], options);
+    return {
+      provenCheckpointNumber: CheckpointNumber.fromBigInt(result[0]),
+      provenArchive: Fr.fromString(result[1]),
+      pendingCheckpointNumber: CheckpointNumber.fromBigInt(result[2]),
+      pendingArchive: Fr.fromString(result[3]),
+      archiveOfMyCheckpoint: Fr.fromString(result[4]),
+    };
   }
 
-  async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
+  async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }): Promise<boolean> {
     await checkBlockTag(options?.blockNumber, this.client);
     return this.rollup.read.canPruneAtTime([timestamp], options);
   }
 
-  archive() {
-    return this.rollup.read.archive();
+  async archive(): Promise<Fr> {
+    return Fr.fromString(await this.rollup.read.archive());
   }
 
-  archiveAt(blockNumber: bigint) {
-    return this.rollup.read.archiveAt([blockNumber]);
+  async archiveAt(checkpointNumber: CheckpointNumber): Promise<Fr> {
+    return Fr.fromString(await this.rollup.read.archiveAt([BigInt(checkpointNumber)]));
   }
 
-  getSequencerRewards(address: Hex | EthAddress) {
+  getSequencerRewards(address: Hex | EthAddress): Promise<bigint> {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
     return this.rollup.read.getSequencerRewards([address]);
   }
 
-  getSpecificProverRewardsForEpoch(epoch: bigint, prover: Hex | EthAddress) {
+  getSpecificProverRewardsForEpoch(epoch: bigint, prover: Hex | EthAddress): Promise<bigint> {
     if (prover instanceof EthAddress) {
       prover = prover.toString();
     }
     return this.rollup.read.getSpecificProverRewardsForEpoch([epoch, prover]);
   }
 
-  async getAttesters() {
+  async getAttesters(): Promise<EthAddress[]> {
     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 indices = Array.from({ length: attesterSize }, (_, i) => BigInt(i));
     const chunks = chunk(indices, 1000);
 
-    return (await Promise.all(chunks.map(chunk => gse.getAttestersFromIndicesAtTime(this.address, ts, chunk)))).flat();
+    const results = await Promise.all(chunks.map(chunk => gse.getAttestersFromIndicesAtTime(this.address, ts, chunk)));
+    return results.flat().map(addr => EthAddress.fromString(addr));
   }
 
-  getAttesterView(address: Hex | EthAddress) {
+  async getAttesterView(address: Hex | EthAddress): Promise<AttesterView> {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
-    return this.rollup.read.getAttesterView([address]);
+    const result = await this.rollup.read.getAttesterView([address]);
+    return {
+      status: result.status as AttesterStatus,
+      effectiveBalance: result.effectiveBalance,
+      exit: {
+        withdrawalId: result.exit.withdrawalId,
+        amount: result.exit.amount,
+        exitableAt: result.exit.exitableAt,
+        recipientOrWithdrawer: EthAddress.fromString(result.exit.recipientOrWithdrawer),
+        isRecipient: result.exit.isRecipient,
+        exists: result.exit.exists,
+      },
+      config: {
+        publicKey: {
+          x: result.config.publicKey.x,
+          y: result.config.publicKey.y,
+        },
+        withdrawer: EthAddress.fromString(result.config.withdrawer),
+      },
+    };
   }
 
-  getStatus(address: Hex | EthAddress) {
+  async getStatus(address: Hex | EthAddress): Promise<AttesterStatus> {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
-    return this.rollup.read.getStatus([address]);
+    return (await this.rollup.read.getStatus([address])) as AttesterStatus;
   }
 
-  getBlobCommitmentsHash(blockNumber: bigint) {
-    return this.rollup.read.getBlobCommitmentsHash([blockNumber]);
+  async getBlobCommitmentsHash(checkpointNumber: CheckpointNumber): Promise<Buffer32> {
+    return Buffer32.fromString(await this.rollup.read.getBlobCommitmentsHash([BigInt(checkpointNumber)]));
   }
 
-  getCurrentBlobCommitmentsHash() {
-    return this.rollup.read.getCurrentBlobCommitmentsHash();
+  async getCurrentBlobCommitmentsHash(): Promise<Buffer32> {
+    return Buffer32.fromString(await this.rollup.read.getCurrentBlobCommitmentsHash());
   }
 
-  getStakingAsset() {
-    return this.rollup.read.getStakingAsset();
+  async getStakingAsset(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.rollup.read.getStakingAsset());
   }
 
-  getRewardConfig() {
-    return this.rollup.read.getRewardConfig();
+  async getRewardConfig(): Promise<RewardConfig> {
+    const result = await this.rollup.read.getRewardConfig();
+    return {
+      rewardDistributor: EthAddress.fromString(result.rewardDistributor),
+      sequencerBps: BigInt(result.sequencerBps),
+      booster: EthAddress.fromString(result.booster),
+      checkpointReward: result.checkpointReward,
+    };
   }
 
   setupEpoch(l1TxUtils: L1TxUtils) {
     return l1TxUtils.sendAndMonitorTransaction({
       to: this.address,
+      abi: RollupAbi,
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'setupEpoch',
@@ -734,6 +1021,7 @@ export class RollupContract {
   vote(l1TxUtils: L1TxUtils, proposalId: bigint) {
     return l1TxUtils.sendAndMonitorTransaction({
       to: this.address,
+      abi: RollupAbi,
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'vote',
@@ -760,15 +1048,17 @@ export class RollupContract {
     );
   }
 
-  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
-    return this.rollup.watchEvent.BlockInvalidated(
+  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.blockNumber !== undefined) {
-              callback({ blockNumber: args.blockNumber });
+            if (args.checkpointNumber !== undefined) {
+              callback({ checkpointNumber: CheckpointNumber.fromBigInt(args.checkpointNumber) });
             }
           }
         },
@@ -800,4 +1090,37 @@ 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: (() => {
+            if (!log.args.attestationsHash) {
+              throw new Error(
+                `CheckpointProposed event missing attestationsHash for checkpoint ${log.args.checkpointNumber}`,
+              );
+            }
+            return Buffer32.fromString(log.args.attestationsHash);
+          })(),
+          payloadDigest: (() => {
+            if (!log.args.payloadDigest) {
+              throw new Error(
+                `CheckpointProposed event missing payloadDigest for checkpoint ${log.args.checkpointNumber}`,
+              );
+            }
+            return Buffer32.fromString(log.args.payloadDigest);
+          })(),
+        },
+      }));
+  }
 }