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

package/dest/contracts/rollup.js

@@ -1,32 +1,551 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (kind === 0) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            if (kind === 1 || kind === 3) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+            if (kind === 1 || kind === 4) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        try {
+            return dec(value, ctx);
+        } finally{
+            decoratorFinishedRef.v = true;
+        }
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (kind === 1) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0) {
+                hint = "field";
+            } else if (kind === 10) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) {
+            if (kind === 0 || kind === 1) {
+                desc = {
+                    get: decInfo[3],
+                    set: decInfo[4]
+                };
+            } else if (kind === 3) {
+                desc = {
+                    get: decInfo[3]
+                };
+            } else if (kind === 4) {
+                desc = {
+                    set: decInfo[3]
+                };
+            } else {
+                desc = {
+                    value: decInfo[3]
+                };
+            }
+        } else if (kind !== 0) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+        if (kind === 1) {
+            value = {
+                get: desc.get,
+                set: desc.set
+            };
+        } else if (kind === 2) {
+            value = desc.value;
+        } else if (kind === 3) {
+            value = desc.get;
+        } else if (kind === 4) {
+            value = desc.set;
+        }
+        var newValue, get, set;
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+                if (kind === 0) {
+                    init = newValue;
+                } else if (kind === 1) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for(var i = decs.length - 1; i >= 0; i--){
+                var dec = decs[i];
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+                    if (kind === 0) {
+                        newInit = newValue;
+                    } else if (kind === 1) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+                        value = {
+                            get: get,
+                            set: set
+                        };
+                    } else {
+                        value = newValue;
+                    }
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [
+                                init,
+                                newInit
+                            ];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+        if (kind === 0 || kind === 1) {
+            if (init === void 0) {
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++){
+                        value = ownInitializers[i].call(instance, value);
+                    }
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (kind !== 0) {
+            if (kind === 1) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2) {
+                desc.value = value;
+            } else if (kind === 3) {
+                desc.get = value;
+            } else if (kind === 4) {
+                desc.set = value;
+            }
+            if (isPrivate) {
+                if (kind === 1) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (!Array.isArray(decInfo)) continue;
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+            var isStatic = kind >= 5;
+            var base;
+            var initializers;
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5;
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+            if (kind !== 0 && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                var existingKind = existingNonFields.get(name) || 0;
+                if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) {
+                    throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                } else if (!existingKind && kind > 2) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for(var i = 0; i < initializers.length; i++){
+                    initializers[i].call(instance);
+                }
+                return instance;
+            });
+        }
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                try {
+                    var nextNewClass = classDecs[i](newClass, {
+                        kind: "class",
+                        name: name,
+                        addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                        metadata
+                    });
+                } finally{
+                    decoratorFinishedRef.v = true;
+                }
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++){
+                        initializers[i].call(newClass);
+                    }
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
 }
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _initProto;
+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 { createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { getErrorCause } from '@aztec/foundation/types';
+import { EscapeHatchAbi } from '@aztec/l1-artifacts/EscapeHatchAbi';
 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 { ContractFunctionRevertedError, RpcRequestError, decodeErrorResult, encodeAbiParameters, encodeFunctionData, getContract, hexToBigInt, keccak256 } from 'viem';
 import { getPublicClient } from '../client.js';
 import { formatViemError } from '../utils.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 { SlashingProposerContract } from './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;
+/**
+ * Status of a validator/attester in the staking system.
+ * Matches the Status enum in StakingLib.sol
+ */ export var AttesterStatus = /*#__PURE__*/ function(AttesterStatus) {
+    AttesterStatus[AttesterStatus["NONE"] = 0] = "NONE";
+    AttesterStatus[AttesterStatus["VALIDATING"] = 1] = "VALIDATING";
+    AttesterStatus[AttesterStatus["ZOMBIE"] = 2] = "ZOMBIE";
+    AttesterStatus[AttesterStatus["EXITING"] = 3] = "EXITING";
+    return AttesterStatus;
+}({});
+/** Field offsets within the CompressedTempCheckpointLog struct in Solidity storage. */ export var TempCheckpointLogField = /*#__PURE__*/ function(TempCheckpointLogField) {
+    TempCheckpointLogField[TempCheckpointLogField["HeaderHash"] = 0] = "HeaderHash";
+    TempCheckpointLogField[TempCheckpointLogField["BlobCommitmentsHash"] = 1] = "BlobCommitmentsHash";
+    TempCheckpointLogField[TempCheckpointLogField["OutHash"] = 2] = "OutHash";
+    TempCheckpointLogField[TempCheckpointLogField["AttestationsHash"] = 3] = "AttestationsHash";
+    TempCheckpointLogField[TempCheckpointLogField["PayloadDigest"] = 4] = "PayloadDigest";
+    TempCheckpointLogField[TempCheckpointLogField["SlotNumber"] = 5] = "SlotNumber";
+    TempCheckpointLogField[TempCheckpointLogField["FeeHeader"] = 6] = "FeeHeader";
+    return TempCheckpointLogField;
 }({});
+const INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR = 'ValidatorSelection__InsufficientValidatorSetSize';
+function isValidatorSelectionError(err, errorName) {
+    return getErrorCause(err, ContractFunctionRevertedError)?.data?.errorName === errorName || decodeRpcRequestErrorName(err) === errorName;
+}
+function decodeRpcRequestErrorName(err) {
+    const data = getErrorCause(err, RpcRequestError)?.data;
+    if (!isHexString(data)) {
+        return undefined;
+    }
+    try {
+        return decodeErrorResult({
+            abi: RollupAbi,
+            data
+        }).errorName;
+    } catch  {
+        return undefined;
+    }
+}
+function isHexString(value) {
+    return typeof value === 'string' && value.startsWith('0x');
+}
 export class RollupContract {
     client;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                memoize,
+                2,
+                "getL1StartBlock"
+            ],
+            [
+                memoize,
+                2,
+                "getL1GenesisTime"
+            ],
+            [
+                memoize,
+                2,
+                "getProofSubmissionEpochs"
+            ],
+            [
+                memoize,
+                2,
+                "getEpochDuration"
+            ],
+            [
+                memoize,
+                2,
+                "getSlotDuration"
+            ],
+            [
+                memoize,
+                2,
+                "getTargetCommitteeSize"
+            ],
+            [
+                memoize,
+                2,
+                "getEjectionThreshold"
+            ],
+            [
+                memoize,
+                2,
+                "getLocalEjectionThreshold"
+            ],
+            [
+                memoize,
+                2,
+                "getLagInEpochsForValidatorSet"
+            ],
+            [
+                memoize,
+                2,
+                "getLagInEpochsForRandao"
+            ],
+            [
+                memoize,
+                2,
+                "getActivationThreshold"
+            ],
+            [
+                memoize,
+                2,
+                "getExitDelay"
+            ],
+            [
+                memoize,
+                2,
+                "getManaTarget"
+            ],
+            [
+                memoize,
+                2,
+                "getProvingCostPerMana"
+            ],
+            [
+                memoize,
+                2,
+                "getProvingCostPerManaInFeeAsset"
+            ],
+            [
+                memoize,
+                2,
+                "getManaLimit"
+            ],
+            [
+                memoize,
+                2,
+                "getVersion"
+            ],
+            [
+                memoize,
+                2,
+                "getGenesisArchiveTreeRoot"
+            ],
+            [
+                memoize,
+                2,
+                "getVkTreeRoot"
+            ],
+            [
+                memoize,
+                2,
+                "getProtocolContractsHash"
+            ],
+            [
+                memoize,
+                2,
+                "getRollupConstants"
+            ]
+        ], []));
+    }
     rollup;
+    logger;
     static cachedStfStorageSlot;
+    cachedEscapeHatch;
     static get checkBlobStorageSlot() {
         const asString = RollupStorage.find((storage)=>storage.label === 'checkBlob')?.slot;
         if (asString === undefined) {
@@ -43,11 +562,12 @@ export class RollupContract {
     }
     static getFromConfig(config) {
         const client = getPublicClient(config);
-        const address = config.l1Contracts.rollupAddress.toString();
+        const address = config.rollupAddress.toString();
         return new RollupContract(client, address);
     }
     constructor(client, address){
         this.client = client;
+        this.logger = (_initProto(this), createLogger('ethereum:rollup'));
         if (address instanceof EthAddress) {
             address = address.toString();
         }
@@ -57,8 +577,8 @@ export class RollupContract {
             client
         });
     }
-    getGSE() {
-        return this.rollup.read.getGSE();
+    async getGSE() {
+        return EthAddress.fromString(await this.rollup.read.getGSE());
     }
     get address() {
         return this.rollup.address;
@@ -72,34 +592,10 @@ export class RollupContract {
             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 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}`);
+        if (proposerAddress.isZero()) {
+            return undefined;
         }
+        return new SlashingProposerContract(this.client, proposerAddress);
     }
     getL1StartBlock() {
         return this.rollup.read.L1_BLOCK_AT_GENESIS();
@@ -107,17 +603,17 @@ export class RollupContract {
     getL1GenesisTime() {
         return this.rollup.read.getGenesisTime();
     }
-    getProofSubmissionEpochs() {
-        return this.rollup.read.getProofSubmissionEpochs();
+    async getProofSubmissionEpochs() {
+        return Number(await this.rollup.read.getProofSubmissionEpochs());
     }
-    getEpochDuration() {
-        return this.rollup.read.getEpochDuration();
+    async getEpochDuration() {
+        return Number(await 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();
+    async getTargetCommitteeSize() {
+        return Number(await this.rollup.read.getTargetCommitteeSize());
     }
     getEjectionThreshold() {
         return this.rollup.read.getEjectionThreshold();
@@ -125,14 +621,17 @@ export class RollupContract {
     getLocalEjectionThreshold() {
         return this.rollup.read.getLocalEjectionThreshold();
     }
-    getLagInEpochs() {
-        return this.rollup.read.getLagInEpochs();
+    async getLagInEpochsForValidatorSet() {
+        return Number(await this.rollup.read.getLagInEpochsForValidatorSet());
+    }
+    async getLagInEpochsForRandao() {
+        return Number(await this.rollup.read.getLagInEpochsForRandao());
     }
     getActivationThreshold() {
         return this.rollup.read.getActivationThreshold();
     }
-    getExitDelay() {
-        return this.rollup.read.getExitDelay();
+    async getExitDelay() {
+        return Number(await this.rollup.read.getExitDelay());
     }
     getManaTarget() {
         return this.rollup.read.getManaTarget();
@@ -150,47 +649,116 @@ export class RollupContract {
         return this.rollup.read.getVersion();
     }
     async getGenesisArchiveTreeRoot() {
-        return await this.rollup.read.archiveAt([
+        return Fr.fromString(await this.rollup.read.archiveAt([
             0n
-        ]);
+        ]));
+    }
+    async getVkTreeRoot() {
+        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');
+    }
+    async getProtocolContractsHash() {
+        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');
     }
     /**
    * 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([
+        const [l1StartBlock, l1GenesisTime, slotDuration, epochDuration, proofSubmissionEpochs, targetCommitteeSize, rollupManaLimit] = await Promise.all([
             this.getL1StartBlock(),
             this.getL1GenesisTime(),
             this.getSlotDuration(),
             this.getEpochDuration(),
-            this.getProofSubmissionEpochs()
+            this.getProofSubmissionEpochs(),
+            this.getTargetCommitteeSize(),
+            this.getManaLimit()
         ]);
         return {
             l1StartBlock,
             l1GenesisTime,
-            slotDuration: Number(slotDuration),
+            slotDuration,
             epochDuration: Number(epochDuration),
-            proofSubmissionEpochs: Number(proofSubmissionEpochs)
+            proofSubmissionEpochs: Number(proofSubmissionEpochs),
+            targetCommitteeSize,
+            rollupManaLimit: Number(rollupManaLimit)
         };
     }
-    getSlasherAddress() {
-        return this.rollup.read.getSlasher();
+    async getSlasherAddress() {
+        return EthAddress.fromString(await this.rollup.read.getSlasher());
+    }
+    /**
+   * Returns the configured escape hatch contract address, or zero if disabled.
+   */ async getEscapeHatchAddress() {
+        return EthAddress.fromString(await this.rollup.read.getEscapeHatch());
+    }
+    async getEscapeHatchContract() {
+        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) {
+        try {
+            const escapeHatch = await this.getEscapeHatchContract();
+            if (!escapeHatch) {
+                return false;
+            }
+            const [isOpen] = await escapeHatch.read.isHatchOpen([
+                BigInt(epoch)
+            ]);
+            return isOpen;
+        } catch (err) {
+            this.logger.warn('isEscapeHatchOpen failed (treating as closed); RPC or contract error may cause liveness risk', {
+                epoch: Number(epoch),
+                error: err
+            });
+            return false;
+        }
     }
     /**
    * Returns a SlasherContract instance for interacting with the slasher contract.
    */ async getSlasherContract() {
-        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() {
+        return EthAddress.fromString(await this.rollup.read.owner());
     }
-    getActiveAttesterCount() {
-        return this.rollup.read.getActiveAttesterCount();
+    async getActiveAttesterCount(options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return Number(await this.rollup.read.getActiveAttesterCount(options));
     }
     async getSlashingProposerAddress() {
         const slasher = await this.getSlasherContract();
@@ -199,25 +767,45 @@ export class RollupContract {
         }
         return await slasher.getProposer();
     }
-    getBlockReward() {
-        return this.rollup.read.getBlockReward();
+    getCheckpointReward() {
+        return this.rollup.read.getCheckpointReward();
     }
-    getBlockNumber() {
-        return this.rollup.read.getPendingBlockNumber();
+    async getCheckpointNumber(options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber(options));
     }
-    getProvenBlockNumber() {
-        return this.rollup.read.getProvenBlockNumber();
+    async getProvenCheckpointNumber(options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber(options));
     }
-    getSlotNumber() {
-        return this.rollup.read.getCurrentSlot();
+    async getSlotNumber(options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot(options));
     }
-    getL1FeesAt(timestamp) {
-        return this.rollup.read.getL1FeesAt([
+    async getL1FeesAt(timestamp, options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        const result = await this.rollup.read.getL1FeesAt([
             timestamp
+        ], options);
+        return {
+            baseFee: result.baseFee,
+            blobFee: result.blobFee
+        };
+    }
+    async getFeeHeader(checkpointNumber) {
+        const result = await this.rollup.read.getFeeHeader([
+            checkpointNumber
         ]);
+        return {
+            excessMana: result.excessMana,
+            manaUsed: result.manaUsed,
+            ethPerFeeAsset: result.ethPerFeeAsset,
+            congestionCost: result.congestionCost,
+            proverCost: result.proverCost
+        };
     }
-    getFeeAssetPerEth() {
-        return this.rollup.read.getFeeAssetPerEth();
+    getEthPerFeeAsset() {
+        return this.rollup.read.getEthPerFeeAsset();
     }
     async getCommitteeAt(timestamp) {
         const { result } = await this.client.simulateContract({
@@ -228,25 +816,25 @@ export class RollupContract {
                 timestamp
             ]
         }).catch((e)=>{
-            if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+            if (isValidatorSelectionError(e, INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR)) {
                 return {
                     result: undefined
                 };
             }
             throw e;
         });
-        return result;
+        return result ? result.map((addr)=>EthAddress.fromString(addr)) : undefined;
     }
-    getSampleSeedAt(timestamp) {
-        return this.rollup.read.getSampleSeedAt([
+    async getSampleSeedAt(timestamp) {
+        return Buffer32.fromBigInt(await this.rollup.read.getSampleSeedAt([
             timestamp
-        ]);
+        ]));
     }
-    getCurrentSampleSeed() {
-        return this.rollup.read.getCurrentSampleSeed();
+    async getCurrentSampleSeed() {
+        return Buffer32.fromBigInt(await this.rollup.read.getCurrentSampleSeed());
     }
-    getCurrentEpoch() {
-        return this.rollup.read.getCurrentEpoch();
+    async getCurrentEpoch() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
     }
     async getCurrentEpochCommittee() {
         const { result } = await this.client.simulateContract({
@@ -255,14 +843,14 @@ export class RollupContract {
             functionName: 'getCurrentEpochCommittee',
             args: []
         }).catch((e)=>{
-            if (e instanceof Error && e.message.includes('ValidatorSelection__InsufficientValidatorSetSize')) {
+            if (isValidatorSelectionError(e, INSUFFICIENT_VALIDATOR_SET_SIZE_ERROR)) {
                 return {
                     result: undefined
                 };
             }
             throw e;
         });
-        return result;
+        return result ? result.map((addr)=>EthAddress.fromString(addr)) : undefined;
     }
     async getCurrentProposer() {
         const { result } = await this.client.simulateContract({
@@ -271,7 +859,7 @@ export class RollupContract {
             functionName: 'getCurrentProposer',
             args: []
         });
-        return result;
+        return EthAddress.fromString(result);
     }
     async getProposerAt(timestamp) {
         const { result } = await this.client.simulateContract({
@@ -282,37 +870,92 @@ export class RollupContract {
                 timestamp
             ]
         });
-        return result;
+        return EthAddress.fromString(result);
     }
-    getBlock(blockNumber) {
-        return this.rollup.read.getBlock([
-            BigInt(blockNumber)
-        ]);
+    async getCheckpoint(checkpointNumber, options) {
+        await checkBlockTag(options?.blockNumber, this.client);
+        const result = await this.rollup.read.getCheckpoint([
+            BigInt(checkpointNumber)
+        ], options);
+        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();
+    /**
+   * Returns the effective pending checkpoint, accounting for potential prunes.
+   * When a prune can happen, the L1 contract uses the proven checkpoint instead of the pending one.
+   * This mirrors the behavior of getEffectivePendingCheckpointNumber in STFLib.sol.
+   * @param atTimestamp - The timestamp to evaluate pruneability at. Defaults to the current L1 block timestamp.
+   * @param options - Optional L1 block number to pin the queries to.
+   */ getEffectivePendingCheckpoint(atTimestamp, options) {
+        return retry(async ()=>{
+            const timestamp = atTimestamp ?? (await this.client.getBlock()).timestamp;
+            const canPrune = await this.canPruneAtTime(timestamp, options);
+            if (canPrune) {
+                const provenCheckpointNumber = await this.getProvenCheckpointNumber(options);
+                return await this.getCheckpoint(provenCheckpointNumber, options);
+            }
+            const pendingCheckpointNumber = await this.getCheckpointNumber(options);
+            return await this.getCheckpoint(pendingCheckpointNumber, options);
+        }, 'getting effective 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)
         ]);
     }
-    getEntryQueueLength() {
-        return this.rollup.read.getEntryQueueLength();
+    async getEntryQueueLength() {
+        return Number(await this.rollup.read.getEntryQueueLength());
     }
-    getAvailableValidatorFlushes() {
-        return this.rollup.read.getAvailableValidatorFlushes();
+    async getAvailableValidatorFlushes() {
+        return Number(await this.rollup.read.getAvailableValidatorFlushes());
     }
-    getNextFlushableEpoch() {
-        return this.rollup.read.getNextFlushableEpoch();
+    async getNextFlushableEpoch() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getNextFlushableEpoch());
     }
-    getCurrentEpochNumber() {
-        return this.rollup.read.getCurrentEpoch();
+    async getCurrentEpochNumber() {
+        return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
     }
-    getEpochNumberForBlock(blockNumber) {
-        return this.rollup.read.getEpochForBlock([
-            BigInt(blockNumber)
-        ]);
+    async getEpochNumberForCheckpoint(checkpointNumber) {
+        return EpochNumber.fromBigInt(await this.rollup.read.getEpochForCheckpoint([
+            BigInt(checkpointNumber)
+        ]));
     }
     async getRollupAddresses() {
         const [inboxAddress, outboxAddress, feeJuicePortalAddress, rewardDistributorAddress, feeJuiceAddress, stakingAssetAddress, gseAddress] = (await Promise.all([
@@ -339,12 +982,13 @@ export class RollupContract {
         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 getEpochProofPublicInputs(args) {
+        const result = await this.rollup.read.getEpochProofPublicInputs(args);
+        return result.map(Fr.fromString);
     }
     async validateHeader(args, account) {
         try {
@@ -365,17 +1009,14 @@ 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, opts = {}) {
-        if (typeof slotDuration === 'number') {
-            slotDuration = BigInt(slotDuration);
-        }
-        const latestBlock = await this.client.getBlock();
-        const timeOfNextL1Slot = latestBlock.timestamp + slotDuration;
+   */ async canProposeAt(archive, account, timestamp, stateOverride = []) {
+        const timeOfNextL1Slot = timestamp;
         const who = typeof account === 'string' ? account : account.address;
         try {
-            const { result: [slot, blockNumber] } = await this.client.simulateContract({
+            const { result: [slot, checkpointNumber] } = await this.client.simulateContract({
                 address: this.address,
                 abi: RollupAbi,
                 functionName: 'canProposeAtTime',
@@ -385,11 +1026,11 @@ export class RollupContract {
                     who
                 ],
                 account,
-                stateOverride: await this.makePendingBlockNumberOverride(opts.forcePendingBlockNumber)
+                stateOverride
             });
             return {
-                slot,
-                blockNumber,
+                slot: SlotNumber.fromBigInt(slot),
+                checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber),
                 timeOfNextL1Slot
             };
         } catch (err) {
@@ -397,11 +1038,15 @@ export class RollupContract {
         }
     }
     /**
-   * 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
-   * stored in the same slot. If the argument is undefined, it returns an empty override.
-   */ async makePendingBlockNumberOverride(forcePendingBlockNumber) {
-        if (forcePendingBlockNumber === undefined) {
+   * Returns a state override that sets the pending and/or proven checkpoint numbers. Useful for simulations.
+   * Both values share a single storage slot (pending in the upper 128 bits, proven in the lower 128 bits), so
+   * a single combined override is emitted to avoid the second state-diff clobbering the first. The current live
+   * value is read once to preserve any half not being overridden. Returns an empty override if neither is set.
+   *
+   * Throws if the resulting `proven > pending`, which would crash the simulation: `STFLib.canPruneAtTime` calls
+   * `getEpochForCheckpoint(proven + 1)` whenever `pending != proven`, and that asserts `_n <= tips.pending`.
+   */ async makeChainTipsOverride(override) {
+        if (override.pending === undefined && override.proven === undefined) {
             return [];
         }
         const slot = RollupContract.stfStorageSlot;
@@ -409,8 +1054,15 @@ export class RollupContract {
             address: this.address,
             slot
         });
-        const currentProvenBlockNumber = currentValue ? hexToBigInt(currentValue) & (1n << 128n) - 1n : 0n;
-        const newValue = BigInt(forcePendingBlockNumber) << 128n | currentProvenBlockNumber;
+        const currentRaw = currentValue ? hexToBigInt(currentValue) : 0n;
+        const currentPending = currentRaw >> 128n;
+        const currentProven = currentRaw & (1n << 128n) - 1n;
+        const newPending = override.pending !== undefined ? BigInt(override.pending) : currentPending;
+        const newProven = override.proven !== undefined ? BigInt(override.proven) : currentProven;
+        if (newProven > newPending) {
+            throw new Error(`Invalid chain tips override: proven (${newProven}) > pending (${newPending})`);
+        }
+        const newValue = newPending << 128n | newProven;
         return [
             {
                 address: this.address,
@@ -423,14 +1075,170 @@ export class RollupContract {
             }
         ];
     }
-    /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */ buildInvalidateBadAttestationRequest(blockNumber, attestationsAndSigners, committee, invalidIndex) {
+    /**
+   * Returns a state override that patches `tempCheckpointLogs[checkpointNumber]` with every field that
+   * the L1 contract reads during `propose()` for the checkpoint that builds on top of it (proposer
+   * pipelining simulation). Mirrors the writes done by `ProposeLib.addTempCheckpointLog`.
+   *
+   * `blobCommitmentsHash` and `attestationsHash` are intentionally not exposed here — the propose path
+   * never asserts against them, so leaving them at storage zero is harmless.
+   */ async makeTempCheckpointLogOverride(checkpointNumber, fields) {
+        const constants = await this.getRollupConstants();
+        const slotAt = (field)=>`0x${this.computeTempCheckpointLogStorageSlot(checkpointNumber, field, constants).toString(16).padStart(64, '0')}`;
+        const word = (v)=>`0x${v.toString(16).padStart(64, '0')}`;
+        const stateDiff = [];
+        if (fields.headerHash) {
+            stateDiff.push({
+                slot: slotAt(0),
+                value: fields.headerHash.toString()
+            });
+        }
+        if (fields.outHash) {
+            stateDiff.push({
+                slot: slotAt(2),
+                value: fields.outHash.toString()
+            });
+        }
+        if (fields.payloadDigest) {
+            stateDiff.push({
+                slot: slotAt(4),
+                value: fields.payloadDigest.toString()
+            });
+        }
+        if (fields.slotNumber !== undefined) {
+            // CompressedSlot is uint32 on L1 (SafeCast.toUint32 reverts on overflow). Match that behavior here
+            // so a malformed override surfaces immediately rather than silently truncating into a wrong slot.
+            const slotNumber = BigInt(fields.slotNumber);
+            if (slotNumber < 0n || slotNumber > 0xffffffffn) {
+                throw new Error(`slotNumber ${slotNumber} does not fit in uint32`);
+            }
+            stateDiff.push({
+                slot: slotAt(5),
+                value: word(slotNumber)
+            });
+        }
+        if (fields.feeHeader) {
+            stateDiff.push({
+                slot: slotAt(6),
+                value: word(RollupContract.compressFeeHeader(fields.feeHeader))
+            });
+        }
+        if (stateDiff.length === 0) {
+            return [];
+        }
+        return [
+            {
+                address: this.address,
+                stateDiff
+            }
+        ];
+    }
+    /**
+   * Returns a state override that sets archives[checkpointNumber] to the given archive value.
+   * Used when simulating a canProposeAtTime call where the local archive differs from L1
+   * (e.g. pipelining where the parent checkpoint hasn't landed on L1 yet).
+   */ makeArchiveOverride(checkpointNumber, archive) {
+        const archivesMappingBase = hexToBigInt(RollupContract.stfStorageSlot) + 1n;
+        const archiveSlot = hexToBigInt(keccak256(encodeAbiParameters([
+            {
+                type: 'uint256'
+            },
+            {
+                type: 'uint256'
+            }
+        ], [
+            BigInt(checkpointNumber),
+            archivesMappingBase
+        ])));
+        return [
+            {
+                address: this.address,
+                stateDiff: [
+                    {
+                        slot: `0x${archiveSlot.toString(16).padStart(64, '0')}`,
+                        value: archive.toString()
+                    }
+                ]
+            }
+        ];
+    }
+    /** Merges multiple StateOverride arrays, combining stateDiff entries for the same address. */ static mergeStateOverrides(...overrides) {
+        const byAddress = new Map();
+        for (const override of overrides){
+            for (const entry of override){
+                const key = entry.address.toLowerCase();
+                const existing = byAddress.get(key);
+                if (existing) {
+                    existing.stateDiff.push(...entry.stateDiff ?? []);
+                    if (entry.balance !== undefined) {
+                        existing.balance = entry.balance;
+                    }
+                } else {
+                    byAddress.set(key, {
+                        address: entry.address,
+                        balance: entry.balance,
+                        stateDiff: [
+                            ...entry.stateDiff ?? []
+                        ]
+                    });
+                }
+            }
+        }
+        return [
+            ...byAddress.values()
+        ];
+    }
+    /** Compresses a FeeHeader into a uint256 matching FeeHeaderLib.compress() in FeeStructs.sol. */ static compressFeeHeader(feeHeader) {
+        const MASK_48_BITS = (1n << 48n) - 1n;
+        const MASK_64_BITS = (1n << 64n) - 1n;
+        const MASK_63_BITS = (1n << 63n) - 1n;
+        let value = BigInt(feeHeader.manaUsed) & (1n << 32n) - 1n; // bits [0:31]
+        value |= (feeHeader.excessMana < MASK_48_BITS ? feeHeader.excessMana : MASK_48_BITS) << 32n; // bits [32:79]
+        value |= (BigInt(feeHeader.ethPerFeeAsset) & MASK_48_BITS) << 80n; // bits [80:127]
+        value |= (feeHeader.congestionCost < MASK_64_BITS ? feeHeader.congestionCost : MASK_64_BITS) << 128n; // bits [128:191]
+        value |= (feeHeader.proverCost < MASK_63_BITS ? feeHeader.proverCost : MASK_63_BITS) << 192n; // bits [192:254]
+        value |= 1n << 255n; // preheat flag
+        return value;
+    }
+    /** Computes the fee header for a child checkpoint given parent fee header and child data.
+   *  Must stay in sync with Solidity FeeLib.sol (computeNewEthPerFeeAsset, clampedAdd). */ static computeChildFeeHeader(parentFeeHeader, childManaUsed, feeAssetPriceModifier, manaTarget) {
+        const MIN_ETH_PER_FEE_ASSET = 100n;
+        const MAX_ETH_PER_FEE_ASSET = 100_000_000_000_000n; // 1e14, matches FeeLib.sol
+        // excessMana = clampedAdd(parent.excessMana + parent.manaUsed, -manaTarget)
+        const sum = parentFeeHeader.excessMana + parentFeeHeader.manaUsed;
+        const excessMana = sum > manaTarget ? sum - manaTarget : 0n;
+        // ethPerFeeAsset = computeNewEthPerFeeAsset(max(parent.ethPerFeeAsset, MIN), modifier)
+        const parentPrice = parentFeeHeader.ethPerFeeAsset > MIN_ETH_PER_FEE_ASSET ? parentFeeHeader.ethPerFeeAsset : MIN_ETH_PER_FEE_ASSET;
+        let newPrice;
+        if (feeAssetPriceModifier >= 0n) {
+            newPrice = parentPrice * (10_000n + feeAssetPriceModifier) / 10_000n;
+        } else {
+            const absMod = -feeAssetPriceModifier;
+            newPrice = parentPrice * (10_000n - absMod) / 10_000n;
+        }
+        if (newPrice < MIN_ETH_PER_FEE_ASSET) {
+            newPrice = MIN_ETH_PER_FEE_ASSET;
+        }
+        if (newPrice > MAX_ETH_PER_FEE_ASSET) {
+            newPrice = MAX_ETH_PER_FEE_ASSET;
+        }
+        return {
+            excessMana,
+            manaUsed: childManaUsed,
+            ethPerFeeAsset: newPrice,
+            congestionCost: 0n,
+            proverCost: 0n
+        };
+    }
+    /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */ buildInvalidateBadAttestationRequest(checkpointNumber, attestationsAndSigners, committee, invalidIndex) {
         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)
@@ -438,46 +1246,68 @@ export class RollupContract {
             })
         };
     }
-    /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */ buildInvalidateInsufficientAttestationsRequest(blockNumber, attestationsAndSigners, committee) {
+    /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */ buildInvalidateInsufficientAttestationsRequest(checkpointNumber, attestationsAndSigners, committee) {
         return {
             to: this.address,
+            abi: RollupAbi,
             data: encodeFunctionData({
                 abi: RollupAbi,
                 functionName: 'invalidateInsufficientAttestations',
                 args: [
-                    BigInt(blockNumber),
+                    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, numberOfBlocksInEpoch, prover) {
+    /** 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),
+            BigInt(numberOfCheckpointsInEpoch),
             prover
         ]);
     }
-    getManaBaseFeeAt(timestamp, inFeeAsset) {
-        return this.rollup.read.getManaBaseFeeAt([
+    getManaMinFeeAt(timestamp, inFeeAsset, stateOverride) {
+        return this.rollup.read.getManaMinFeeAt([
+            timestamp,
+            inFeeAsset
+        ], {
+            stateOverride
+        });
+    }
+    async getManaMinFeeComponentsAt(timestamp, inFeeAsset) {
+        const result = await this.rollup.read.getManaMinFeeComponentsAt([
             timestamp,
             inFeeAsset
         ]);
+        return {
+            sequencerCost: result.sequencerCost,
+            proverCost: result.proverCost,
+            congestionCost: result.congestionCost,
+            congestionMultiplier: result.congestionMultiplier
+        };
     }
-    getSlotAt(timestamp) {
-        return this.rollup.read.getSlotAt([
+    async getSlotAt(timestamp) {
+        return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([
             timestamp
-        ]);
+        ]));
     }
-    async status(blockNumber, options) {
+    async status(checkpointNumber, options) {
         await checkBlockTag(options?.blockNumber, this.client);
-        return this.rollup.read.status([
-            blockNumber
+        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, options) {
         await checkBlockTag(options?.blockNumber, this.client);
@@ -485,13 +1315,13 @@ export class RollupContract {
             timestamp
         ], options);
     }
-    archive() {
-        return this.rollup.read.archive();
+    async archive() {
+        return Fr.fromString(await this.rollup.read.archive());
     }
-    archiveAt(blockNumber) {
-        return this.rollup.read.archiveAt([
-            blockNumber
-        ]);
+    async archiveAt(checkpointNumber) {
+        return Fr.fromString(await this.rollup.read.archiveAt([
+            BigInt(checkpointNumber)
+        ]));
     }
     getSequencerRewards(address) {
         if (address instanceof EthAddress) {
@@ -510,49 +1340,85 @@ export class RollupContract {
             prover
         ]);
     }
-    async getAttesters() {
-        const attesterSize = await this.getActiveAttesterCount();
+    async getAttesters(timestamp) {
+        // Pin every read to a single L1 block so the attester count and the chunked index reads
+        // observe a consistent set. Without this, the count and each chunk default to `latest` and
+        // can straddle a block boundary (or reorg), yielding an inconsistent or truncated set.
+        const block = await this.client.getBlock();
+        const blockNumber = block.number ?? undefined;
+        const ts = timestamp ?? block.timestamp;
+        const attesterSize = await this.getActiveAttesterCount({
+            blockNumber
+        });
         const gse = new GSEContract(this.client, await this.getGSE());
-        const ts = (await this.client.getBlock()).timestamp;
         const indices = Array.from({
-            length: Number(attesterSize)
+            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, {
+                blockNumber
+            })));
+        return results.flat().map((addr)=>EthAddress.fromString(addr));
     }
-    getAttesterView(address) {
+    async getAttesterView(address) {
         if (address instanceof EthAddress) {
             address = address.toString();
         }
-        return this.rollup.read.getAttesterView([
+        const result = await this.rollup.read.getAttesterView([
             address
         ]);
+        return {
+            status: result.status,
+            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) {
+    async getStatus(address) {
         if (address instanceof EthAddress) {
             address = address.toString();
         }
-        return this.rollup.read.getStatus([
+        return await this.rollup.read.getStatus([
             address
         ]);
     }
-    getBlobCommitmentsHash(blockNumber) {
-        return this.rollup.read.getBlobCommitmentsHash([
-            blockNumber
-        ]);
+    async getBlobCommitmentsHash(checkpointNumber) {
+        return Buffer32.fromString(await this.rollup.read.getBlobCommitmentsHash([
+            BigInt(checkpointNumber)
+        ]));
     }
-    getCurrentBlobCommitmentsHash() {
-        return this.rollup.read.getCurrentBlobCommitmentsHash();
+    async getCurrentBlobCommitmentsHash() {
+        return Buffer32.fromString(await this.rollup.read.getCurrentBlobCommitmentsHash());
     }
-    getStakingAsset() {
-        return this.rollup.read.getStakingAsset();
+    async getStakingAsset() {
+        return EthAddress.fromString(await this.rollup.read.getStakingAsset());
     }
-    getRewardConfig() {
-        return this.rollup.read.getRewardConfig();
+    async getRewardConfig() {
+        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) {
         return l1TxUtils.sendAndMonitorTransaction({
             to: this.address,
+            abi: RollupAbi,
             data: encodeFunctionData({
                 abi: RollupAbi,
                 functionName: 'setupEpoch',
@@ -563,6 +1429,7 @@ export class RollupContract {
     vote(l1TxUtils, proposalId) {
         return l1TxUtils.sendAndMonitorTransaction({
             to: this.address,
+            abi: RollupAbi,
             data: encodeFunctionData({
                 abi: RollupAbi,
                 functionName: 'vote',
@@ -584,14 +1451,15 @@ export class RollupContract {
             }
         });
     }
-    listenToBlockInvalidated(callback) {
-        return this.rollup.watchEvent.BlockInvalidated({}, {
+    listenToCheckpointInvalidated(callback) {
+        return this.rollup.watchEvent.CheckpointInvalidated({}, {
             onLogs: (logs)=>{
                 for (const log of logs){
                     const args = log.args;
-                    if (args.blockNumber !== undefined) {
+                    if (args.checkpointNumber !== undefined) {
                         callback({
-                            blockNumber: args.blockNumber
+                            checkpointNumber: CheckpointNumber.fromBigInt(args.checkpointNumber),
+                            event: log
                         });
                     }
                 }
@@ -622,58 +1490,83 @@ export class RollupContract {
             }
         });
     }
+    /**
+   * Fetches OwnershipTransferred events emitted on the L1 block this rollup was deployed on.
+   * The Rollup inherits from Ownable and emits this event in its constructor, so the event
+   * is guaranteed to exist on `l1StartBlock` for any correctly deployed rollup. Used as a
+   * probe to detect RPC nodes that prune historical logs.
+   */ async getOwnershipTransferredEventsAtDeploy() {
+        const l1StartBlock = await this.getL1StartBlock();
+        return await this.rollup.getEvents.OwnershipTransferred({}, {
+            fromBlock: l1StartBlock,
+            toBlock: l1StartBlock
+        });
+    }
+    /** Fetches CheckpointProposed events within the given block range. */ async getCheckpointProposedEvents(fromBlock, toBlock) {
+        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);
+                    })()
+                }
+            }));
+    }
+    /** Packs pending and proven checkpoint numbers into the chain tips storage format. */ static packChainTips(pendingCheckpointNumber, provenCheckpointNumber) {
+        return pendingCheckpointNumber << 128n | provenCheckpointNumber & (1n << 128n) - 1n;
+    }
+    /** Storage slot for the chain tips (offset 0 within the STF storage struct). */ static get chainTipsStorageSlot() {
+        return BigInt(RollupContract.stfStorageSlot);
+    }
+    /**
+   * Computes the storage slot for a field within a tempCheckpointLog entry.
+   * @param checkpointNumber - The checkpoint number
+   * @param field - The field within the CompressedTempCheckpointLog struct
+   */ async getTempCheckpointLogStorageSlot(checkpointNumber, field) {
+        const [epochDuration, proofSubmissionEpochs] = await Promise.all([
+            this.getEpochDuration(),
+            this.getProofSubmissionEpochs()
+        ]);
+        return this.computeTempCheckpointLogStorageSlot(checkpointNumber, field, {
+            epochDuration,
+            proofSubmissionEpochs
+        });
+    }
+    computeTempCheckpointLogStorageSlot(checkpointNumber, field, constants) {
+        const fieldOffset = BigInt(field);
+        const { epochDuration, proofSubmissionEpochs } = constants;
+        const roundaboutSize = BigInt(epochDuration) * (BigInt(proofSubmissionEpochs) + 1n) + 1n;
+        const tempCheckpointLogsBase = BigInt(RollupContract.stfStorageSlot) + 2n;
+        const circularIndex = BigInt(checkpointNumber) % roundaboutSize;
+        const entryBase = BigInt(keccak256(encodeAbiParameters([
+            {
+                type: 'uint256'
+            },
+            {
+                type: 'uint256'
+            }
+        ], [
+            circularIndex,
+            tempCheckpointLogsBase
+        ])));
+        return entryBase + fieldOffset;
+    }
 }
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getL1StartBlock", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getL1GenesisTime", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getProofSubmissionEpochs", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getEpochDuration", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getSlotDuration", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getTargetCommitteeSize", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getEjectionThreshold", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getLocalEjectionThreshold", null);
-_ts_decorate([
-    memoize
-], RollupContract.prototype, "getLagInEpochs", 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);