@aztec/archiver 4.0.0-nightly.20260114 → 4.0.0-nightly.20260115

package/dest/archiver.js

@@ -0,0 +1,767 @@
+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 _dec, _initProto;
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockTagTooOldError } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { merge } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/running-promise';
+import { GENESIS_CHECKPOINT_HEADER_HASH } from '@aztec/stdlib/block';
+import { getEpochNumberAtTimestamp, getSlotAtTimestamp, getSlotRangeForEpoch, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { trackSpan } from '@aztec/telemetry-client';
+import { mapArchiverConfig } from './config.js';
+import { NoBlobBodiesFoundError } from './errors.js';
+import { validateAndLogTraceAvailability } from './l1/validate_trace.js';
+import { ArchiverDataSourceBase } from './modules/data_source_base.js';
+import { ArchiverDataStoreUpdater } from './modules/data_store_updater.js';
+_dec = trackSpan('Archiver.sync');
+/**
+ * Pulls checkpoints in a non-blocking manner and provides interface for their retrieval.
+ * Responsible for handling robust L1 polling so that other components do not need to
+ * concern themselves with it.
+ */ export class Archiver extends ArchiverDataSourceBase {
+    publicClient;
+    debugClient;
+    rollup;
+    l1Addresses;
+    dataStore;
+    config;
+    blobClient;
+    l1Constants;
+    log;
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "sync"
+            ]
+        ], []));
+    }
+    /** Event emitter for archiver events (L2BlockProven, L2PruneDetected, etc). */ events;
+    /** A loop in which we will be continually fetching new checkpoints. */ runningPromise;
+    /** L1 synchronizer that handles fetching checkpoints and messages from L1. */ synchronizer;
+    initialSyncComplete;
+    initialSyncPromise;
+    /** Queue of blocks to be added to the store, processed by the sync loop. */ blockQueue;
+    /** Helper to handle updates to the store */ updater;
+    tracer;
+    /**
+   * Creates a new instance of the Archiver.
+   * @param publicClient - A client for interacting with the Ethereum node.
+   * @param debugClient - A client for interacting with the Ethereum node for debug/trace methods.
+   * @param rollup - Rollup contract instance.
+   * @param inbox - Inbox contract instance.
+   * @param l1Addresses - L1 contract addresses (registry, governance proposer, slash factory, slashing proposer).
+   * @param dataStore - An archiver data store for storage & retrieval of blocks, encrypted logs & contract data.
+   * @param config - Archiver configuration options.
+   * @param blobClient - Client for retrieving blob data.
+   * @param epochCache - Cache for epoch-related data.
+   * @param dateProvider - Provider for current date/time.
+   * @param instrumentation - Instrumentation for metrics and tracing.
+   * @param l1Constants - L1 rollup constants.
+   * @param log - A logger.
+   */ constructor(publicClient, debugClient, rollup, l1Addresses, dataStore, config, blobClient, instrumentation, l1Constants, synchronizer, events, log = createLogger('archiver')){
+        super(dataStore, l1Constants), this.publicClient = publicClient, this.debugClient = debugClient, this.rollup = rollup, this.l1Addresses = l1Addresses, this.dataStore = dataStore, this.config = config, this.blobClient = blobClient, this.l1Constants = l1Constants, this.log = log, this.initialSyncComplete = (_initProto(this), false), this.blockQueue = [];
+        this.tracer = instrumentation.tracer;
+        this.initialSyncPromise = promiseWithResolvers();
+        this.synchronizer = synchronizer;
+        this.events = events;
+        this.updater = new ArchiverDataStoreUpdater(this.dataStore);
+        // Running promise starts with a small interval inbetween runs, so all iterations needed for the initial sync
+        // are done as fast as possible. This then gets updated once the initial sync completes.
+        this.runningPromise = new RunningPromise(()=>this.sync(), this.log, this.config.pollingIntervalMs / 10, makeLoggingErrorHandler(this.log, NoBlobBodiesFoundError, BlockTagTooOldError));
+    }
+    /** Updates archiver config */ updateConfig(newConfig) {
+        this.config = merge(this.config, mapArchiverConfig(newConfig));
+    }
+    /**
+   * Starts sync process.
+   * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
+   */ async start(blockUntilSynced) {
+        if (this.runningPromise.isRunning()) {
+            throw new Error('Archiver is already running');
+        }
+        await this.blobClient.testSources();
+        await this.synchronizer.testEthereumNodeSynced();
+        await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false);
+        // Log initial state for the archiver
+        const { l1StartBlock } = this.l1Constants;
+        const { blocksSynchedTo = l1StartBlock, messagesSynchedTo = l1StartBlock } = await this.store.getSynchPoint();
+        const currentL2Checkpoint = await this.getSynchedCheckpointNumber();
+        this.log.info(`Starting archiver sync to rollup contract ${this.rollup.address} from L1 block ${blocksSynchedTo} and L2 checkpoint ${currentL2Checkpoint}`, {
+            blocksSynchedTo,
+            messagesSynchedTo,
+            currentL2Checkpoint
+        });
+        // Start sync loop, and return the wait for initial sync if we are asked to block until synced
+        this.runningPromise.start();
+        if (blockUntilSynced) {
+            return this.waitForInitialSync();
+        }
+    }
+    syncImmediate() {
+        return this.runningPromise.trigger();
+    }
+    /**
+   * Queues a block to be added to the archiver store and triggers processing.
+   * The block will be processed by the sync loop.
+   * Implements the L2BlockSink interface.
+   * @param block - The L2 block to add.
+   * @returns A promise that resolves when the block has been added to the store, or rejects on error.
+   */ addBlock(block) {
+        return new Promise((resolve, reject)=>{
+            this.blockQueue.push({
+                block,
+                resolve,
+                reject
+            });
+            this.log.debug(`Queued block ${block.number} for processing`);
+            // Trigger an immediate sync, but don't wait for it - the promise resolves when the block is processed
+            this.syncImmediate().catch((err)=>{
+                this.log.error(`Sync immediate call failed: ${err}`);
+            });
+        });
+    }
+    /**
+   * Processes all queued blocks, adding them to the store.
+   * Called at the beginning of each sync iteration.
+   * Blocks are processed in the order they were queued.
+   */ async processQueuedBlocks() {
+        if (this.blockQueue.length === 0) {
+            return;
+        }
+        // Take all blocks from the queue
+        const queuedItems = this.blockQueue.splice(0, this.blockQueue.length);
+        this.log.debug(`Processing ${queuedItems.length} queued block(s)`);
+        // Process each block individually to properly resolve/reject each promise
+        for (const { block, resolve, reject } of queuedItems){
+            try {
+                await this.updater.addBlocksWithContractData([
+                    block
+                ]);
+                this.log.debug(`Added block ${block.number} to store`);
+                resolve();
+            } catch (err) {
+                this.log.error(`Failed to add block ${block.number} to store: ${err.message}`);
+                reject(err);
+            }
+        }
+    }
+    waitForInitialSync() {
+        return this.initialSyncPromise.promise;
+    }
+    /**
+   * Fetches logs from L1 contracts and processes them.
+   */ async sync() {
+        // Process any queued blocks first, before doing L1 sync
+        await this.processQueuedBlocks();
+        // Now perform L1 sync
+        await this.syncFromL1();
+    }
+    async syncFromL1() {
+        // Delegate to the L1 synchronizer
+        await this.synchronizer.syncFromL1(this.initialSyncComplete);
+        // Check if we've completed initial sync
+        const currentL1BlockNumber = this.synchronizer.getL1BlockNumber();
+        if (currentL1BlockNumber !== undefined && !this.initialSyncComplete) {
+            const l1BlockNumberAtEnd = await this.publicClient.getBlockNumber();
+            if (currentL1BlockNumber + 1n >= l1BlockNumberAtEnd) {
+                this.log.info(`Initial archiver sync to L1 block ${currentL1BlockNumber} complete`, {
+                    l1BlockNumber: currentL1BlockNumber,
+                    syncPoint: await this.store.getSynchPoint(),
+                    ...await this.getL2Tips()
+                });
+                this.runningPromise.setPollingIntervalMS(this.config.pollingIntervalMs);
+                this.initialSyncComplete = true;
+                this.initialSyncPromise.resolve();
+            }
+        }
+    }
+    /** Resumes the archiver after a stop. */ resume() {
+        if (this.runningPromise.isRunning()) {
+            this.log.warn(`Archiver already running`);
+        }
+        this.log.info(`Restarting archiver`);
+        this.runningPromise.start();
+    }
+    /**
+   * Stops the archiver.
+   * @returns A promise signalling completion of the stop process.
+   */ async stop() {
+        this.log.debug('Stopping...');
+        await this.runningPromise.stop();
+        this.log.info('Stopped.');
+        return Promise.resolve();
+    }
+    backupTo(destPath) {
+        return this.dataStore.backupTo(destPath);
+    }
+    getL1Constants() {
+        return Promise.resolve(this.l1Constants);
+    }
+    getGenesisValues() {
+        return Promise.resolve({
+            genesisArchiveRoot: this.l1Constants.genesisArchiveRoot
+        });
+    }
+    getRollupAddress() {
+        return Promise.resolve(EthAddress.fromString(this.rollup.address));
+    }
+    getRegistryAddress() {
+        return Promise.resolve(this.l1Addresses.registryAddress);
+    }
+    getL1BlockNumber() {
+        return this.synchronizer.getL1BlockNumber();
+    }
+    getL1Timestamp() {
+        return Promise.resolve(this.synchronizer.getL1Timestamp());
+    }
+    getL2SlotNumber() {
+        const l1Timestamp = this.synchronizer.getL1Timestamp();
+        return Promise.resolve(l1Timestamp === undefined ? undefined : getSlotAtTimestamp(l1Timestamp, this.l1Constants));
+    }
+    getL2EpochNumber() {
+        const l1Timestamp = this.synchronizer.getL1Timestamp();
+        return Promise.resolve(l1Timestamp === undefined ? undefined : getEpochNumberAtTimestamp(l1Timestamp, this.l1Constants));
+    }
+    async isEpochComplete(epochNumber) {
+        // The epoch is complete if the current L2 block is the last one in the epoch (or later)
+        const header = await this.getBlockHeader('latest');
+        const slot = header ? header.globalVariables.slotNumber : undefined;
+        const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
+        if (slot && slot >= endSlot) {
+            return true;
+        }
+        // If we haven't run an initial sync, just return false.
+        const l1Timestamp = this.synchronizer.getL1Timestamp();
+        if (l1Timestamp === undefined) {
+            return false;
+        }
+        // If not, the epoch may also be complete if the L2 slot has passed without a block
+        // We compute this based on the end timestamp for the given epoch and the timestamp of the last L1 block
+        const [_startTimestamp, endTimestamp] = getTimestampRangeForEpoch(epochNumber, this.l1Constants);
+        // For this computation, we throw in a few extra seconds just for good measure,
+        // since we know the next L1 block won't be mined within this range. Remember that
+        // l1timestamp is the timestamp of the last l1 block we've seen, so this relies on
+        // the fact that L1 won't mine two blocks within this time of each other.
+        // TODO(palla/reorg): Is the above a safe assumption?
+        const leeway = 1n;
+        return l1Timestamp + leeway >= endTimestamp;
+    }
+    /** Returns whether the archiver has completed an initial sync run successfully. */ isInitialSyncComplete() {
+        return this.initialSyncComplete;
+    }
+    unwindCheckpoints(from, checkpointsToUnwind) {
+        return this.updater.unwindCheckpointsWithContractData(from, checkpointsToUnwind);
+    }
+    addCheckpoints(checkpoints, pendingChainValidationStatus) {
+        return this.updater.addCheckpointsWithContractData(checkpoints, pendingChainValidationStatus);
+    }
+    async getL2Tips() {
+        const [latestBlockNumber, provenBlockNumber, checkpointedBlockNumber] = await Promise.all([
+            this.getBlockNumber(),
+            this.getProvenBlockNumber(),
+            this.getCheckpointedBlockNumber()
+        ]);
+        // TODO(#13569): Compute proper finalized block number based on L1 finalized block.
+        // We just force it 2 epochs worth of proven data for now.
+        // NOTE: update end-to-end/src/e2e_epochs/epochs_empty_blocks.test.ts as that uses finalized blocks in computations
+        const finalizedBlockNumber = BlockNumber(Math.max(provenBlockNumber - this.l1Constants.epochDuration * 2, 0));
+        const beforeInitialblockNumber = BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
+        // Get the latest block header and checkpointed blocks for proven, finalised and checkpointed blocks
+        const [latestBlockHeader, provenCheckpointedBlock, finalizedCheckpointedBlock, checkpointedBlock] = await Promise.all([
+            latestBlockNumber > beforeInitialblockNumber ? this.getBlockHeader(latestBlockNumber) : undefined,
+            provenBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(provenBlockNumber) : undefined,
+            finalizedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(finalizedBlockNumber) : undefined,
+            checkpointedBlockNumber > beforeInitialblockNumber ? this.getCheckpointedBlock(checkpointedBlockNumber) : undefined
+        ]);
+        if (latestBlockNumber > beforeInitialblockNumber && !latestBlockHeader) {
+            throw new Error(`Failed to retrieve latest block header for block ${latestBlockNumber}`);
+        }
+        // Checkpointed blocks must exist for proven, finalized and checkpointed tips if they are beyond the initial block number.
+        if (checkpointedBlockNumber > beforeInitialblockNumber && !checkpointedBlock?.block.header) {
+            throw new Error(`Failed to retrieve checkpointed block header for block ${checkpointedBlockNumber} (latest block is ${latestBlockNumber})`);
+        }
+        if (provenBlockNumber > beforeInitialblockNumber && !provenCheckpointedBlock?.block.header) {
+            throw new Error(`Failed to retrieve proven checkpointed for block ${provenBlockNumber} (latest block is ${latestBlockNumber})`);
+        }
+        if (finalizedBlockNumber > beforeInitialblockNumber && !finalizedCheckpointedBlock?.block.header) {
+            throw new Error(`Failed to retrieve finalized block header for block ${finalizedBlockNumber} (latest block is ${latestBlockNumber})`);
+        }
+        const latestBlockHeaderHash = await latestBlockHeader?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        const provenBlockHeaderHash = await provenCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        const finalizedBlockHeaderHash = await finalizedCheckpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        const checkpointedBlockHeaderHash = await checkpointedBlock?.block.header?.hash() ?? GENESIS_BLOCK_HEADER_HASH;
+        // Now attempt to retrieve checkpoints for proven, finalised and checkpointed blocks
+        const [[provenBlockCheckpoint], [finalizedBlockCheckpoint], [checkpointedBlockCheckpoint]] = await Promise.all([
+            provenCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(provenCheckpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ],
+            finalizedCheckpointedBlock !== undefined ? await this.getPublishedCheckpoints(finalizedCheckpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ],
+            checkpointedBlock !== undefined ? await this.getPublishedCheckpoints(checkpointedBlock?.checkpointNumber, 1) : [
+                undefined
+            ]
+        ]);
+        const initialcheckpointId = {
+            number: CheckpointNumber.ZERO,
+            hash: GENESIS_CHECKPOINT_HEADER_HASH.toString()
+        };
+        const makeCheckpointId = (checkpoint)=>{
+            if (checkpoint === undefined) {
+                return initialcheckpointId;
+            }
+            return {
+                number: checkpoint.checkpoint.number,
+                hash: checkpoint.checkpoint.hash().toString()
+            };
+        };
+        const l2Tips = {
+            proposed: {
+                number: latestBlockNumber,
+                hash: latestBlockHeaderHash.toString()
+            },
+            proven: {
+                block: {
+                    number: provenBlockNumber,
+                    hash: provenBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(provenBlockCheckpoint)
+            },
+            finalized: {
+                block: {
+                    number: finalizedBlockNumber,
+                    hash: finalizedBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(finalizedBlockCheckpoint)
+            },
+            checkpointed: {
+                block: {
+                    number: checkpointedBlockNumber,
+                    hash: checkpointedBlockHeaderHash.toString()
+                },
+                checkpoint: makeCheckpointId(checkpointedBlockCheckpoint)
+            }
+        };
+        return l2Tips;
+    }
+    async rollbackTo(targetL2BlockNumber) {
+        // TODO(pw/mbps): This still assumes 1 block per checkpoint
+        const currentBlocks = await this.getL2Tips();
+        const currentL2Block = currentBlocks.proposed.number;
+        const currentProvenBlock = currentBlocks.proven.block.number;
+        if (targetL2BlockNumber >= currentL2Block) {
+            throw new Error(`Target L2 block ${targetL2BlockNumber} must be less than current L2 block ${currentL2Block}`);
+        }
+        const blocksToUnwind = currentL2Block - targetL2BlockNumber;
+        const targetL2Block = await this.store.getCheckpointedBlock(targetL2BlockNumber);
+        if (!targetL2Block) {
+            throw new Error(`Target L2 block ${targetL2BlockNumber} not found`);
+        }
+        const targetL1BlockNumber = targetL2Block.l1.blockNumber;
+        const targetCheckpointNumber = CheckpointNumber.fromBlockNumber(targetL2BlockNumber);
+        const targetL1Block = await this.publicClient.getBlock({
+            blockNumber: targetL1BlockNumber,
+            includeTransactions: false
+        });
+        if (!targetL1Block) {
+            throw new Error(`Missing L1 block ${targetL1BlockNumber}`);
+        }
+        const targetL1BlockHash = Buffer32.fromString(targetL1Block.hash);
+        this.log.info(`Unwinding ${blocksToUnwind} checkpoints from L2 block ${currentL2Block}`);
+        await this.updater.unwindCheckpointsWithContractData(CheckpointNumber(currentL2Block), blocksToUnwind);
+        this.log.info(`Unwinding L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
+        await this.store.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
+        this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
+        await this.store.setCheckpointSynchedL1BlockNumber(targetL1BlockNumber);
+        await this.store.setMessageSynchedL1Block({
+            l1BlockNumber: targetL1BlockNumber,
+            l1BlockHash: targetL1BlockHash
+        });
+        if (targetL2BlockNumber < currentProvenBlock) {
+            this.log.info(`Clearing proven L2 block number`);
+            await this.store.setProvenCheckpointNumber(CheckpointNumber.ZERO);
+        }
+    // TODO(palla/reorg): Set the finalized block when we add support for it.
+    // if (targetL2BlockNumber < currentFinalizedBlock) {
+    //   this.log.info(`Clearing finalized L2 block number`);
+    //   await this.store.setFinalizedL2BlockNumber(0);
+    // }
+    }
+}