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

package/src/contracts/rollup.ts

@@ -1,9 +1,9 @@
+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 } 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 +11,8 @@ import {
   type GetContractReturnType,
   type Hex,
   type StateOverride,
+  type WatchContractEventReturnType,
   encodeFunctionData,
-  getAddress,
   getContract,
   hexToBigInt,
   keccak256,
@@ -22,7 +22,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';
@@ -62,6 +62,7 @@ export type EpochProofPublicInputArgs = {
 
 export type ViemHeader = {
   lastArchiveRoot: `0x${string}`;
+  blockHeadersHash: `0x${string}`;
   contentCommitment: ViemContentCommitment;
   slotNumber: bigint;
   timestamp: bigint;
@@ -82,22 +83,6 @@ export type ViemGasFees = {
   feePerL2Gas: bigint;
 };
 
-export type ViemStateReference = {
-  l1ToL2MessageTree: ViemAppendOnlyTreeSnapshot;
-  partialStateReference: ViemPartialStateReference;
-};
-
-export type ViemPartialStateReference = {
-  noteHashTree: ViemAppendOnlyTreeSnapshot;
-  nullifierTree: ViemAppendOnlyTreeSnapshot;
-  publicDataTree: ViemAppendOnlyTreeSnapshot;
-};
-
-export type ViemAppendOnlyTreeSnapshot = {
-  root: `0x${string}`;
-  nextAvailableLeafIndex: number;
-};
-
 export enum SlashingProposerType {
   None = 0,
   Tally = 1,
@@ -160,13 +145,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 +161,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);
@@ -209,8 +193,8 @@ export class RollupContract {
   }
 
   @memoize
-  getSlotDuration() {
-    return this.rollup.read.getSlotDuration();
+  async getSlotDuration(): Promise<number> {
+    return Number(await this.rollup.read.getSlotDuration());
   }
 
   @memoize
@@ -223,6 +207,21 @@ export class RollupContract {
     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();
@@ -260,20 +259,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,
+      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,29 +315,27 @@ 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() {
-    return this.rollup.read.getBlockReward();
+  getCheckpointReward() {
+    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(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber());
   }
 
-  getSlotNumber() {
-    return this.rollup.read.getCurrentSlot();
+  async getSlotNumber(): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
   }
 
   getL1FeesAt(timestamp: bigint) {
@@ -344,8 +372,8 @@ export class RollupContract {
     return 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> {
@@ -388,25 +416,40 @@ export class RollupContract {
     return result;
   }
 
-  getBlock(blockNumber: bigint) {
-    return this.rollup.read.getBlock([blockNumber]);
+  getCheckpoint(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
   }
 
-  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) {
+    return this.rollup.read.getTimestampForSlot([BigInt(slot)]);
   }
 
   getEntryQueueLength() {
     return this.rollup.read.getEntryQueueLength();
   }
 
-  async getEpochNumber(blockNumber?: bigint) {
-    blockNumber ??= await this.getBlockNumber();
-    return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
+  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> {
@@ -446,8 +489,8 @@ 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(
@@ -461,6 +504,7 @@ export class RollupContract {
       ViemHeader,
       ViemCommitteeAttestations,
       `0x${string}`[],
+      ViemSignature,
       `0x${string}`,
       `0x${string}`,
       {
@@ -483,130 +527,63 @@ 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
    *
    * @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,
-    opts: { forcePendingBlockNumber?: number } = {},
-  ): Promise<{ slot: bigint; blockNumber: bigint; timeOfNextL1Slot: bigint }> {
-    if (typeof slotDuration === 'number') {
-      slotDuration = BigInt(slotDuration);
-    }
+    slotDuration: number,
+    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 + BigInt(slotDuration);
     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,
@@ -617,8 +594,8 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
   public buildInvalidateBadAttestationRequest(
-    blockNumber: number,
-    attestations: ViemCommitteeAttestation[],
+    checkpointNumber: CheckpointNumber,
+    attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
     invalidIndex: number,
   ): L1TxRequest {
@@ -628,8 +605,8 @@ export class RollupContract {
         abi: RollupAbi,
         functionName: 'invalidateBadAttestation',
         args: [
-          BigInt(blockNumber),
-          RollupContract.packAttestations(attestations),
+          BigInt(checkpointNumber),
+          attestationsAndSigners,
           committee.map(addr => addr.toString()),
           BigInt(invalidIndex),
         ],
@@ -639,8 +616,8 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
   public buildInvalidateInsufficientAttestationsRequest(
-    blockNumber: number,
-    attestations: ViemCommitteeAttestation[],
+    checkpointNumber: CheckpointNumber,
+    attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
   ): L1TxRequest {
     return {
@@ -648,34 +625,30 @@ export class RollupContract {
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateInsufficientAttestations',
-        args: [
-          BigInt(blockNumber),
-          RollupContract.packAttestations(attestations),
-          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]);
   }
 
-  getSlotAt(timestamp: bigint) {
-    return this.rollup.read.getSlotAt([timestamp]);
+  async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
   }
 
-  async status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+  async status(checkpointNumber: CheckpointNumber, options?: { blockNumber?: bigint }) {
     await checkBlockTag(options?.blockNumber, this.client);
-    return this.rollup.read.status([blockNumber], options);
+    return this.rollup.read.status([BigInt(checkpointNumber)], options);
   }
 
   async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
@@ -687,8 +660,8 @@ export class RollupContract {
     return this.rollup.read.archive();
   }
 
-  archiveAt(blockNumber: bigint) {
-    return this.rollup.read.archiveAt([blockNumber]);
+  archiveAt(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.archiveAt([BigInt(checkpointNumber)]);
   }
 
   getSequencerRewards(address: Hex | EthAddress) {
@@ -730,8 +703,8 @@ export class RollupContract {
     return this.rollup.read.getStatus([address]);
   }
 
-  getBlobCommitmentsHash(blockNumber: bigint) {
-    return this.rollup.read.getBlobCommitmentsHash([blockNumber]);
+  getBlobCommitmentsHash(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getBlobCommitmentsHash([BigInt(checkpointNumber)]);
   }
 
   getCurrentBlobCommitmentsHash() {
@@ -742,6 +715,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 +741,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 +759,24 @@ export class RollupContract {
     );
   }
 
+  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 => ({
@@ -788,7 +785,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