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

package/dest/contracts/rollup.js

@@ -4,16 +4,31 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { RollupAbi, RollupStorage, SlasherAbi } from '@aztec/l1-artifacts';
-import { 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 { encodeFunctionData, getContract, hexToBigInt, keccak256 } from 'viem';
 import { getPublicClient } from '../client.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 var SlashingProposerType = /*#__PURE__*/ function(SlashingProposerType) {
+    SlashingProposerType[SlashingProposerType["None"] = 0] = "None";
+    SlashingProposerType[SlashingProposerType["Tally"] = 1] = "Tally";
+    SlashingProposerType[SlashingProposerType["Empire"] = 2] = "Empire";
+    return SlashingProposerType;
+}({});
 export class RollupContract {
     client;
     rollup;
+    static cachedStfStorageSlot;
     static get checkBlobStorageSlot() {
         const asString = RollupStorage.find((storage)=>storage.label === 'checkBlob')?.slot;
         if (asString === undefined) {
@@ -21,9 +36,12 @@ export class RollupContract {
         }
         return BigInt(asString);
     }
+    static get stfStorageSlot() {
+        return RollupContract.cachedStfStorageSlot ??= keccak256(Buffer.from('aztec.stf.storage', 'utf-8'));
+    }
     static getFromL1ContractsValues(deployL1ContractsValues) {
-        const { publicClient, l1ContractAddresses: { rollupAddress } } = deployL1ContractsValues;
-        return new RollupContract(publicClient, rollupAddress.toString());
+        const { l1Client, l1ContractAddresses: { rollupAddress } } = deployL1ContractsValues;
+        return new RollupContract(l1Client, rollupAddress.toString());
     }
     static getFromConfig(config) {
         const client = getPublicClient(config);
@@ -41,18 +59,49 @@ export class RollupContract {
             client
         });
     }
+    getGSE() {
+        return this.rollup.read.getGSE();
+    }
     get address() {
         return this.rollup.address;
     }
+    getContract() {
+        return this.rollup;
+    }
     async getSlashingProposer() {
-        const slasherAddress = await this.rollup.read.getSlasher();
-        const slasher = getContract({
-            address: slasherAddress,
-            abi: SlasherAbi,
+        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'
+            }
+        ];
+        const proposer = getContract({
+            address: proposerAddress.toString(),
+            abi: proposerAbi,
             client: this.client
         });
-        const proposerAddress = await slasher.read.PROPOSER();
-        return new SlashingProposerContract(this.client, proposerAddress);
+        const proposerType = await proposer.read.SLASHING_PROPOSER_TYPE();
+        if (proposerType === 1..valueOf()) {
+            return new TallySlashingProposerContract(this.client, proposerAddress);
+        } else if (proposerType === 2..valueOf()) {
+            return new EmpireSlashingProposerContract(this.client, proposerAddress);
+        } else {
+            throw new Error(`Unknown slashing proposer type: ${proposerType}`);
+        }
     }
     getL1StartBlock() {
         return this.rollup.read.L1_BLOCK_AT_GENESIS();
@@ -60,44 +109,139 @@ export class RollupContract {
     getL1GenesisTime() {
         return this.rollup.read.getGenesisTime();
     }
-    getProofSubmissionWindow() {
-        return this.rollup.read.getProofSubmissionWindow();
+    getProofSubmissionEpochs() {
+        return this.rollup.read.getProofSubmissionEpochs();
     }
     getEpochDuration() {
         return this.rollup.read.getEpochDuration();
     }
-    getSlotDuration() {
-        return this.rollup.read.getSlotDuration();
+    async getSlotDuration() {
+        return Number(await this.rollup.read.getSlotDuration());
     }
     getTargetCommitteeSize() {
         return this.rollup.read.getTargetCommitteeSize();
     }
-    getMinimumStake() {
-        return this.rollup.read.getMinimumStake();
+    getEjectionThreshold() {
+        return this.rollup.read.getEjectionThreshold();
+    }
+    getLocalEjectionThreshold() {
+        return this.rollup.read.getLocalEjectionThreshold();
+    }
+    getLagInEpochsForValidatorSet() {
+        return this.rollup.read.getLagInEpochsForValidatorSet();
+    }
+    getLagInEpochsForRandao() {
+        return this.rollup.read.getLagInEpochsForRandao();
+    }
+    getActivationThreshold() {
+        return this.rollup.read.getActivationThreshold();
+    }
+    getExitDelay() {
+        return this.rollup.read.getExitDelay();
+    }
+    getManaTarget() {
+        return this.rollup.read.getManaTarget();
+    }
+    getProvingCostPerMana() {
+        return this.rollup.read.getProvingCostPerManaInEth();
+    }
+    getProvingCostPerManaInFeeAsset() {
+        return this.rollup.read.getProvingCostPerManaInFeeAsset();
+    }
+    getManaLimit() {
+        return this.rollup.read.getManaLimit();
+    }
+    getVersion() {
+        return this.rollup.read.getVersion();
+    }
+    async getGenesisArchiveTreeRoot() {
+        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.
+   */ async getRollupConstants() {
+        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() {
+        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();
     }
     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();
     }
-    getBlockNumber() {
-        return this.rollup.read.getPendingBlockNumber();
+    getCheckpointReward() {
+        return this.rollup.read.getCheckpointReward();
     }
-    getProvenBlockNumber() {
-        return this.rollup.read.getProvenBlockNumber();
+    async getCheckpointNumber() {
+        return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber());
     }
-    getSlotNumber() {
-        return this.rollup.read.getCurrentSlot();
+    async getProvenCheckpointNumber() {
+        return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber());
     }
-    getCommitteeAt(timestamp) {
-        return this.rollup.read.getCommitteeAt([
+    async getSlotNumber() {
+        return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+    }
+    getL1FeesAt(timestamp) {
+        return this.rollup.read.getL1FeesAt([
             timestamp
         ]);
     }
+    getFeeAssetPerEth() {
+        return this.rollup.read.getFeeAssetPerEth();
+    }
+    async getCommitteeAt(timestamp) {
+        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) {
         return this.rollup.read.getSampleSeedAt([
             timestamp
@@ -106,44 +250,101 @@ export class RollupContract {
     getCurrentSampleSeed() {
         return this.rollup.read.getCurrentSampleSeed();
     }
-    getCurrentEpochCommittee() {
-        return this.rollup.read.getCurrentEpochCommittee();
+    async getCurrentEpoch() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
     }
-    getCurrentProposer() {
-        return this.rollup.read.getCurrentProposer();
+    async getCurrentEpochCommittee() {
+        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) {
-        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) {
-        return this.rollup.read.getBlock([
-            blockNumber
+    async getProposerAt(timestamp) {
+        const { result } = await this.client.simulateContract({
+            address: this.address,
+            abi: RollupAbi,
+            functionName: 'getProposerAt',
+            args: [
+                timestamp
+            ]
+        });
+        return result;
+    }
+    getCheckpoint(checkpointNumber) {
+        return this.rollup.read.getCheckpoint([
+            BigInt(checkpointNumber)
         ]);
     }
-    getTips() {
-        return this.rollup.read.getTips();
+    /** 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 getTips() {
+        const { pending, proven } = await this.rollup.read.getTips();
+        return {
+            pending: CheckpointNumber.fromBigInt(pending),
+            proven: CheckpointNumber.fromBigInt(proven)
+        };
     }
     getTimestampForSlot(slot) {
         return this.rollup.read.getTimestampForSlot([
-            slot
+            BigInt(slot)
         ]);
     }
-    async getEpochNumber(blockNumber) {
-        blockNumber ??= await this.getBlockNumber();
-        return this.rollup.read.getEpochForBlock([
-            BigInt(blockNumber)
-        ]);
+    getEntryQueueLength() {
+        return this.rollup.read.getEntryQueueLength();
+    }
+    getAvailableValidatorFlushes() {
+        return this.rollup.read.getAvailableValidatorFlushes();
+    }
+    async getNextFlushableEpoch() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getNextFlushableEpoch());
+    }
+    async getCurrentEpochNumber() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
+    }
+    async getEpochNumberForCheckpoint(checkpointNumber) {
+        return EpochNumber.fromBigInt(await this.rollup.read.getEpochForCheckpoint([
+            BigInt(checkpointNumber)
+        ]));
     }
     async getRollupAddresses() {
-        const [inboxAddress, outboxAddress, feeJuicePortalAddress, rewardDistributorAddress, feeJuiceAddress, stakingAssetAddress] = (await Promise.all([
+        const [inboxAddress, outboxAddress, feeJuicePortalAddress, rewardDistributorAddress, feeJuiceAddress, stakingAssetAddress, gseAddress] = (await Promise.all([
             this.rollup.read.getInbox(),
             this.rollup.read.getOutbox(),
             this.rollup.read.getFeeAssetPortal(),
             this.rollup.read.getRewardDistributor(),
             this.rollup.read.getFeeAsset(),
-            this.rollup.read.getStakingAsset()
+            this.rollup.read.getStakingAsset(),
+            this.rollup.read.getGSE()
         ])).map(EthAddress.fromString);
         return {
             rollupAddress: EthAddress.fromString(this.address),
@@ -152,20 +353,28 @@ export class RollupContract {
             feeJuicePortalAddress,
             feeJuiceAddress,
             stakingAssetAddress,
-            rewardDistributorAddress
+            rewardDistributorAddress,
+            gseAddress
         };
     }
+    async getFeeJuicePortal() {
+        return EthAddress.fromString(await this.rollup.read.getFeeAssetPortal());
+    }
     async getEpochNumberForSlotNumber(slotNumber) {
-        return await this.rollup.read.getEpochAtSlot([
-            slotNumber
-        ]);
+        return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([
+            BigInt(slotNumber)
+        ]));
     }
     getEpochProofPublicInputs(args) {
         return this.rollup.read.getEpochProofPublicInputs(args);
     }
     async validateHeader(args, account) {
         try {
-            await this.rollup.read.validateHeader(args, {
+            await this.client.simulateContract({
+                address: this.address,
+                abi: RollupAbi,
+                functionName: 'validateHeaderWithAttestations',
+                args,
                 account
             });
         } catch (error) {
@@ -178,39 +387,262 @@ 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
-   */ async canProposeAtNextEthBlock(archive, account, slotDuration) {
-        if (typeof slotDuration === 'number') {
-            slotDuration = BigInt(slotDuration);
-        }
-        const timeOfNextL1Slot = (await this.client.getBlock()).timestamp + slotDuration;
+   */ async canProposeAtNextEthBlock(archive, account, slotDuration, opts = {}) {
+        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
+            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,
-                blockNumber
-            ];
+            return {
+                slot: SlotNumber.fromBigInt(slot),
+                checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber),
+                timeOfNextL1Slot
+            };
         } catch (err) {
             throw formatViemError(err);
         }
     }
-    /** Calls getHasSubmitted directly. Returns whether the given prover has submitted a proof with the given length for the given epoch. */ getHasSubmittedProof(epochNumber, numberOfBlocksInEpoch, prover) {
+    /**
+   * 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.
+   */ async makePendingCheckpointNumberOverride(forcePendingCheckpointNumber) {
+        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 */ buildInvalidateBadAttestationRequest(checkpointNumber, attestationsAndSigners, committee, invalidIndex) {
+        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 */ buildInvalidateInsufficientAttestationsRequest(checkpointNumber, attestationsAndSigners, committee) {
+        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. */ getHasSubmittedProof(epochNumber, numberOfCheckpointsInEpoch, prover) {
+        if (prover instanceof EthAddress) {
+            prover = prover.toString();
+        }
         return this.rollup.read.getHasSubmitted([
             BigInt(epochNumber),
-            BigInt(numberOfBlocksInEpoch),
-            prover.toString()
+            BigInt(numberOfCheckpointsInEpoch),
+            prover
+        ]);
+    }
+    getManaBaseFeeAt(timestamp, inFeeAsset) {
+        return this.rollup.read.getManaBaseFeeAt([
+            timestamp,
+            inFeeAsset
+        ]);
+    }
+    async getSlotAt(timestamp) {
+        return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([
+            timestamp
+        ]));
+    }
+    async status(checkpointNumber, options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return this.rollup.read.status([
+            BigInt(checkpointNumber)
+        ], options);
+    }
+    async canPruneAtTime(timestamp, options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return this.rollup.read.canPruneAtTime([
+            timestamp
+        ], options);
+    }
+    archive() {
+        return this.rollup.read.archive();
+    }
+    archiveAt(checkpointNumber) {
+        return this.rollup.read.archiveAt([
+            BigInt(checkpointNumber)
         ]);
     }
+    getSequencerRewards(address) {
+        if (address instanceof EthAddress) {
+            address = address.toString();
+        }
+        return this.rollup.read.getSequencerRewards([
+            address
+        ]);
+    }
+    getSpecificProverRewardsForEpoch(epoch, prover) {
+        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) {
+        if (address instanceof EthAddress) {
+            address = address.toString();
+        }
+        return this.rollup.read.getAttesterView([
+            address
+        ]);
+    }
+    getStatus(address) {
+        if (address instanceof EthAddress) {
+            address = address.toString();
+        }
+        return this.rollup.read.getStatus([
+            address
+        ]);
+    }
+    getBlobCommitmentsHash(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) {
+        return l1TxUtils.sendAndMonitorTransaction({
+            to: this.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'setupEpoch',
+                args: []
+            })
+        });
+    }
+    vote(l1TxUtils, proposalId) {
+        return l1TxUtils.sendAndMonitorTransaction({
+            to: this.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'vote',
+                args: [
+                    proposalId
+                ]
+            })
+        });
+    }
+    listenToSlasherChanged(callback) {
+        return this.rollup.watchEvent.SlasherUpdated({}, {
+            onLogs: (logs)=>{
+                for (const log of logs){
+                    const args = log.args;
+                    if (args.oldSlasher && args.newSlasher) {
+                        callback(args);
+                    }
+                }
+            }
+        });
+    }
+    listenToCheckpointInvalidated(callback) {
+        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)
+                        });
+                    }
+                }
+            }
+        });
+    }
+    async getSlashEvents(l1BlockHash) {
+        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)
+            }));
+    }
+    listenToSlash(callback) {
+        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)
+                    });
+                }
+            }
+        });
+    }
 }
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getSlashingProposer", null);
 _ts_decorate([
     memoize
 ], RollupContract.prototype, "getL1StartBlock", null);
@@ -219,7 +651,7 @@ _ts_decorate([
 ], RollupContract.prototype, "getL1GenesisTime", null);
 _ts_decorate([
     memoize
-], RollupContract.prototype, "getProofSubmissionWindow", null);
+], RollupContract.prototype, "getProofSubmissionEpochs", null);
 _ts_decorate([
     memoize
 ], RollupContract.prototype, "getEpochDuration", null);
@@ -231,4 +663,40 @@ _ts_decorate([
 ], RollupContract.prototype, "getTargetCommitteeSize", null);
 _ts_decorate([
     memoize
-], RollupContract.prototype, "getMinimumStake", null);
+], RollupContract.prototype, "getEjectionThreshold", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getLocalEjectionThreshold", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getLagInEpochsForValidatorSet", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getLagInEpochsForRandao", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getActivationThreshold", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getExitDelay", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getManaTarget", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getProvingCostPerMana", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getProvingCostPerManaInFeeAsset", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getManaLimit", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getVersion", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getGenesisArchiveTreeRoot", null);
+_ts_decorate([
+    memoize
+], RollupContract.prototype, "getRollupConstants", null);