@aztec/sequencer-client 1.2.1 → 2.0.0-nightly.20250813

package/dest/publisher/sequencer-publisher.js

@@ -1,29 +1,31 @@
 import { Blob } from '@aztec/blob-lib';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { FormattedViemError, MULTI_CALL_3_ADDRESS, Multicall3, RollupContract, formatViemError } from '@aztec/ethereum';
+import { FormattedViemError, MULTI_CALL_3_ADDRESS, Multicall3, RollupContract, formatViemError, tryExtractEvent } from '@aztec/ethereum';
 import { sumBigint } from '@aztec/foundation/bigint';
 import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { RollupAbi } from '@aztec/l1-artifacts';
+import { EmpireBaseAbi, ErrorsAbi, RollupAbi } from '@aztec/l1-artifacts';
 import { CommitteeAttestation } from '@aztec/stdlib/block';
 import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import pick from 'lodash.pick';
-import { encodeFunctionData, multicall3Abi, toHex } from 'viem';
+import { encodeFunctionData, toHex } from 'viem';
 import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
-export var VoteType = /*#__PURE__*/ function(VoteType) {
-    VoteType[VoteType["GOVERNANCE"] = 0] = "GOVERNANCE";
-    VoteType[VoteType["SLASHING"] = 1] = "SLASHING";
-    return VoteType;
+export var SignalType = /*#__PURE__*/ function(SignalType) {
+    SignalType[SignalType["GOVERNANCE"] = 0] = "GOVERNANCE";
+    SignalType[SignalType["SLASHING"] = 1] = "SLASHING";
+    return SignalType;
 }({});
 const Actions = [
     'propose',
-    'governance-vote',
-    'slashing-vote'
+    'governance-signal',
+    'slashing-signal',
+    'invalidate-by-invalid-attestation',
+    'invalidate-by-insufficient-attestations'
 ];
-// Sorting for actions such that proposals always go first
+// Sorting for actions such that invalidations go first, then proposals, and last votes
 const compareActions = (a, b)=>Actions.indexOf(b) - Actions.indexOf(a);
 export class SequencerPublisher {
     config;
@@ -31,12 +33,10 @@ export class SequencerPublisher {
     metrics;
     epochCache;
     governanceLog;
-    governanceProposerAddress;
     governancePayload;
     slashingLog;
-    slashingProposerAddress;
     getSlashPayload;
-    myLastVotes;
+    myLastSignals;
     log;
     ethereumSlotDuration;
     blobSinkClient;
@@ -60,7 +60,7 @@ export class SequencerPublisher {
         this.governancePayload = EthAddress.ZERO;
         this.slashingLog = createLogger('sequencer:publisher:slashing');
         this.getSlashPayload = undefined;
-        this.myLastVotes = {
+        this.myLastSignals = {
             [0]: 0n,
             [1]: 0n
         };
@@ -77,6 +77,11 @@ export class SequencerPublisher {
         this.rollupContract = deps.rollupContract;
         this.govProposerContract = deps.governanceProposerContract;
         this.slashingProposerContract = deps.slashingProposerContract;
+        this.rollupContract.listenToSlasherChanged(async ()=>{
+            this.log.info('Slashing proposer changed');
+            const newSlashingProposer = await this.rollupContract.getSlashingProposer();
+            this.slashingProposerContract = newSlashingProposer;
+        });
     }
     getRollupContract() {
         return this.rollupContract;
@@ -160,11 +165,13 @@ export class SequencerPublisher {
                 validRequests: validRequests.map((request)=>request.action)
             });
             const result = await Multicall3.forward(validRequests.map((request)=>request.request), this.l1TxUtils, gasConfig, blobConfig, this.rollupContract.address, this.log);
-            this.callbackBundledTransactions(validRequests, result);
+            const { successfulActions = [], failedActions = [] } = this.callbackBundledTransactions(validRequests, result);
             return {
                 result,
                 expiredActions,
-                validActions
+                sentActions: validActions,
+                successfulActions,
+                failedActions
             };
         } catch (err) {
             const viemError = formatViemError(err);
@@ -179,31 +186,44 @@ export class SequencerPublisher {
         }
     }
     callbackBundledTransactions(requests, result) {
-        const isError = result instanceof FormattedViemError;
-        const success = isError ? false : result?.receipt.status === 'success';
-        const logger = success ? this.log.info : this.log.error;
-        for (const request of requests){
-            logger(`Bundled [${request.action}] transaction [${success ? 'succeeded' : 'failed'}]`);
-            if (!isError) {
-                request.onResult?.(request.request, result);
+        const actionsListStr = requests.map((r)=>r.action).join(', ');
+        if (result instanceof FormattedViemError) {
+            this.log.error(`Failed to publish bundled transactions (${actionsListStr})`, result);
+            return {
+                failedActions: requests.map((r)=>r.action)
+            };
+        } else {
+            this.log.verbose(`Published bundled transactions (${actionsListStr})`, {
+                result,
+                requests
+            });
+            const successfulActions = [];
+            const failedActions = [];
+            for (const request of requests){
+                if (request.checkSuccess(request.request, result)) {
+                    successfulActions.push(request.action);
+                } else {
+                    failedActions.push(request.action);
+                }
             }
-        }
-        if (isError) {
-            this.log.error('Failed to publish bundled transactions', result);
+            return {
+                successfulActions,
+                failedActions
+            };
         }
     }
     /**
    * @notice  Will call `canProposeAtNextEthBlock` to make sure that it is possible to propose
    * @param tipArchive - The archive to check
    * @returns The slot and block number if it is possible to propose, undefined otherwise
-   */ canProposeAtNextEthBlock(tipArchive, msgSender) {
+   */ canProposeAtNextEthBlock(tipArchive, msgSender, opts = {}) {
         // TODO: #14291 - should loop through multiple keys to check if any of them can propose
         const ignoredErrors = [
             'SlotAlreadyInChain',
             'InvalidProposer',
             'InvalidArchive'
         ];
-        return this.rollupContract.canProposeAtNextEthBlock(tipArchive, msgSender.toString(), this.ethereumSlotDuration).catch((err)=>{
+        return this.rollupContract.canProposeAtNextEthBlock(tipArchive.toBuffer(), msgSender.toString(), this.ethereumSlotDuration, opts).catch((err)=>{
             if (err instanceof FormattedViemError && ignoredErrors.find((e)=>err.message.includes(e))) {
                 this.log.warn(`Failed canProposeAtTime check with ${ignoredErrors.find((e)=>err.message.includes(e))}`, {
                     error: err.message
@@ -219,7 +239,7 @@ export class SequencerPublisher {
    * @dev     This is a convenience function that can be used by the sequencer to validate a "partial" header.
    *          It will throw if the block header is invalid.
    * @param header - The block header to validate
-   */ async validateBlockHeader(header) {
+   */ async validateBlockHeader(header, opts) {
         const flags = {
             ignoreDA: true,
             ignoreSignatures: true
@@ -227,6 +247,7 @@ export class SequencerPublisher {
         const args = [
             header.toViem(),
             RollupContract.packAttestations([]),
+            [],
             `0x${'0'.repeat(64)}`,
             header.contentCommitment.blobsHash.toString(),
             flags
@@ -238,7 +259,7 @@ export class SequencerPublisher {
             to: this.rollupContract.address,
             data: encodeFunctionData({
                 abi: RollupAbi,
-                functionName: 'validateHeader',
+                functionName: 'validateHeaderWithAttestations',
                 args
             }),
             from: MULTI_CALL_3_ADDRESS
@@ -248,10 +269,97 @@ export class SequencerPublisher {
             {
                 address: MULTI_CALL_3_ADDRESS,
                 balance
-            }
+            },
+            ...await this.rollupContract.makePendingBlockNumberOverride(opts?.forcePendingBlockNumber)
         ]);
     }
     /**
+   * Simulate making a call to invalidate a block with invalid attestations. Returns undefined if no need to invalidate.
+   * @param block - The block to invalidate and the criteria for invalidation (as returned by the archiver)
+   */ async simulateInvalidateBlock(validationResult) {
+        if (validationResult.valid) {
+            return undefined;
+        }
+        const { reason, block } = validationResult;
+        const blockNumber = block.block.number;
+        const logData = {
+            ...block.block.toBlockInfo(),
+            reason
+        };
+        const currentBlockNumber = await this.rollupContract.getBlockNumber();
+        if (currentBlockNumber < validationResult.block.block.number) {
+            this.log.verbose(`Skipping block ${blockNumber} invalidation since it has already been removed from the pending chain`, {
+                currentBlockNumber,
+                ...logData
+            });
+            return undefined;
+        }
+        const request = this.buildInvalidateBlockRequest(validationResult);
+        this.log.debug(`Simulating invalidate block ${blockNumber}`, logData);
+        try {
+            const { gasUsed } = await this.l1TxUtils.simulate(request, undefined, undefined, ErrorsAbi);
+            this.log.verbose(`Simulation for invalidate block ${blockNumber} succeeded`, {
+                ...logData,
+                request,
+                gasUsed
+            });
+            return {
+                request,
+                gasUsed,
+                blockNumber,
+                forcePendingBlockNumber: blockNumber - 1,
+                reason
+            };
+        } catch (err) {
+            const viemError = formatViemError(err);
+            // If the error is due to the block not being in the pending chain, and it was indeed removed by someone else,
+            // we can safely ignore it and return undefined so we go ahead with block building.
+            if (viemError.message?.includes('Rollup__BlockNotInPendingChain')) {
+                this.log.verbose(`Simulation for invalidate block ${blockNumber} failed due to block not being in pending chain`, {
+                    ...logData,
+                    request,
+                    error: viemError.message
+                });
+                const latestPendingBlockNumber = await this.rollupContract.getBlockNumber();
+                if (latestPendingBlockNumber < blockNumber) {
+                    this.log.verbose(`Block number ${blockNumber} has already been invalidated`, {
+                        ...logData
+                    });
+                    return undefined;
+                } else {
+                    this.log.error(`Simulation for invalidate ${blockNumber} failed and it is still in pending chain`, viemError, logData);
+                    throw new Error(`Failed to simulate invalidate block ${blockNumber} while it is still in pending chain`, {
+                        cause: viemError
+                    });
+                }
+            }
+            // Otherwise, throw. We cannot build the next block if we cannot invalidate the previous one.
+            this.log.error(`Simulation for invalidate block ${blockNumber} failed`, viemError, logData);
+            throw new Error(`Failed to simulate invalidate block ${blockNumber}`, {
+                cause: viemError
+            });
+        }
+    }
+    buildInvalidateBlockRequest(validationResult) {
+        if (validationResult.valid) {
+            throw new Error('Cannot invalidate a valid block');
+        }
+        const { block, committee, reason } = validationResult;
+        const logData = {
+            ...block.block.toBlockInfo(),
+            reason
+        };
+        this.log.debug(`Simulating invalidate block ${block.block.number}`, logData);
+        if (reason === 'invalid-attestation') {
+            return this.rollupContract.buildInvalidateBadAttestationRequest(block.block.number, block.attestations.map((a)=>a.toViem()), committee, validationResult.invalidIndex);
+        } else if (reason === 'insufficient-attestations') {
+            return this.rollupContract.buildInvalidateInsufficientAttestationsRequest(block.block.number, block.attestations.map((a)=>a.toViem()), committee);
+        } else {
+            const _ = reason;
+            throw new Error(`Unknown reason for invalidation`);
+        }
+    }
+    /**
    * @notice  Will simulate `propose` to make sure that the block is valid for submission
    *
    * @dev     Throws if unable to propose
@@ -262,7 +370,7 @@ export class SequencerPublisher {
    */ async validateBlockForSubmission(block, attestationData = {
         digest: Buffer.alloc(32),
         attestations: []
-    }) {
+    }, options) {
         const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
         // If we have no attestations, we still need to provide the empty attestations
         // so that the committee is recalculated correctly
@@ -275,11 +383,10 @@ export class SequencerPublisher {
             }
             attestationData.attestations = committee.map((committeeMember)=>CommitteeAttestation.fromAddress(committeeMember));
         }
-        // const blobs = await Blob.getBlobs(block.body.toBlobFields());
-        // const blobInput = Blob.getEthBlobEvaluationInputs(blobs);
         const blobs = await Blob.getBlobsPerBlock(block.body.toBlobFields());
         const blobInput = Blob.getPrefixedEthBlobCommitments(blobs);
         const formattedAttestations = attestationData.attestations.map((attest)=>attest.toViem());
+        const signers = attestationData.attestations.filter((attest)=>!attest.signature.isEmpty()).map((attest)=>attest.address.toString());
         const args = [
             {
                 header: block.header.toPropose().toViem(),
@@ -291,37 +398,49 @@ export class SequencerPublisher {
                 }
             },
             RollupContract.packAttestations(formattedAttestations),
+            signers,
             blobInput
         ];
-        await this.simulateProposeTx(args, ts);
+        await this.simulateProposeTx(args, ts, options);
         return ts;
     }
-    async getCurrentEpochCommittee() {
-        const committee = await this.rollupContract.getCurrentEpochCommittee();
-        return committee?.map(EthAddress.fromString);
-    }
-    async enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base, signerAddress, signer) {
-        if (this.myLastVotes[voteType] >= slotNumber) {
+    async enqueueCastSignalHelper(slotNumber, timestamp, signalType, payload, base, signerAddress, signer) {
+        if (this.myLastSignals[signalType] >= slotNumber) {
             return false;
         }
         if (payload.equals(EthAddress.ZERO)) {
             return false;
         }
+        if (signerAddress.equals(EthAddress.ZERO)) {
+            this.log.warn(`Cannot enqueue vote cast signal ${signalType} for address zero at slot ${slotNumber}`);
+            return false;
+        }
         const round = await base.computeRound(slotNumber);
         const roundInfo = await base.getRoundInfo(this.rollupContract.address, round);
-        if (roundInfo.lastVote >= slotNumber) {
+        if (roundInfo.lastSignalSlot >= slotNumber) {
             return false;
         }
-        const cachedLastVote = this.myLastVotes[voteType];
-        this.myLastVotes[voteType] = slotNumber;
-        const action = voteType === 0 ? 'governance-vote' : 'slashing-vote';
-        const request = await base.createVoteRequestWithSignature(payload.toString(), this.config.l1ChainId, signerAddress.toString(), signer);
+        const cachedLastVote = this.myLastSignals[signalType];
+        this.myLastSignals[signalType] = slotNumber;
+        const action = signalType === 0 ? 'governance-signal' : 'slashing-signal';
+        const request = await base.createSignalRequestWithSignature(payload.toString(), round, this.config.l1ChainId, signerAddress.toString(), signer);
         this.log.debug(`Created ${action} request with signature`, {
             request,
             round,
             signer: this.l1TxUtils.client.account?.address,
             lastValidL2Slot: slotNumber
         });
+        try {
+            await this.l1TxUtils.simulate(request, {
+                time: timestamp
+            }, [], ErrorsAbi);
+            this.log.debug(`Simulation for ${action} at slot ${slotNumber} succeeded`, {
+                request
+            });
+        } catch (err) {
+            this.log.warn(`Failed simulation for ${action} at slot ${slotNumber} (enqueuing the action anyway)`, err);
+        // Yes, we enqueue the request anyway, in case there was a bug with the simulation itself
+        }
         this.addRequest({
             gasConfig: {
                 gasLimit: SequencerPublisher.VOTE_GAS_GUESS
@@ -329,23 +448,33 @@ export class SequencerPublisher {
             action,
             request,
             lastValidL2Slot: slotNumber,
-            onResult: (_request, result)=>{
-                if (!result || result.receipt.status !== 'success') {
-                    this.myLastVotes[voteType] = cachedLastVote;
+            checkSuccess: (_request, result)=>{
+                const success = result && result.receipt && result.receipt.status === 'success' && tryExtractEvent(result.receipt.logs, base.address.toString(), EmpireBaseAbi, 'SignalCast');
+                const logData = {
+                    ...result,
+                    slotNumber,
+                    round,
+                    payload: payload.toString()
+                };
+                if (!success) {
+                    this.log.error(`Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} failed`, logData);
+                    this.myLastSignals[signalType] = cachedLastVote;
+                    return false;
                 } else {
-                    this.log.info(`Voting in [${action}] for ${payload} at slot ${slotNumber} in round ${round}`);
+                    this.log.info(`Signaling in [${action}] for ${payload} at slot ${slotNumber} in round ${round} succeeded`, logData);
+                    return true;
                 }
             }
         });
         return true;
     }
-    async getVoteConfig(slotNumber, voteType) {
-        if (voteType === 0) {
+    async getSignalConfig(slotNumber, signalType) {
+        if (signalType === 0) {
             return {
                 payload: this.governancePayload,
                 base: this.govProposerContract
             };
-        } else if (voteType === 1) {
+        } else if (signalType === 1) {
             if (!this.getSlashPayload) {
                 return undefined;
             }
@@ -358,26 +487,24 @@ export class SequencerPublisher {
                 payload: slashPayload,
                 base: this.slashingProposerContract
             };
+        } else {
+            const _ = signalType;
+            throw new Error('Unreachable: Invalid signal type');
         }
-        throw new Error('Unreachable: Invalid vote type');
     }
     /**
-   * Enqueues a castVote transaction to cast a vote for a given slot number.
-   * @param slotNumber - The slot number to cast a vote for.
-   * @param timestamp - The timestamp of the slot to cast a vote for.
-   * @param voteType - The type of vote to cast.
-   * @returns True if the vote was successfully enqueued, false otherwise.
-   */ async enqueueCastVote(slotNumber, timestamp, voteType, signerAddress, signer) {
-        const voteConfig = await this.getVoteConfig(slotNumber, voteType);
-        if (!voteConfig) {
+   * Enqueues a castSignal transaction to cast a signal for a given slot number.
+   * @param slotNumber - The slot number to cast a signal for.
+   * @param timestamp - The timestamp of the slot to cast a signal for.
+   * @param signalType - The type of signal to cast.
+   * @returns True if the signal was successfully enqueued, false otherwise.
+   */ async enqueueCastSignal(slotNumber, timestamp, signalType, signerAddress, signer) {
+        const signalConfig = await this.getSignalConfig(slotNumber, signalType);
+        if (!signalConfig) {
             return false;
         }
-        if (signerAddress.equals(EthAddress.ZERO)) {
-            this.log.warn(`Cannot enqueue vote cast signal ${voteType} for address zero at slot ${slotNumber}`);
-            return false;
-        }
-        const { payload, base } = voteConfig;
-        return this.enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base, signerAddress, signer);
+        const { payload, base } = signalConfig;
+        return this.enqueueCastSignalHelper(slotNumber, timestamp, signalType, payload, base, signerAddress, signer);
     }
     /**
    * Proposes a L2 block on L1.
@@ -404,21 +531,64 @@ export class SequencerPublisher {
             //        This means that we can avoid the simulation issues in later checks.
             //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
             //        make time consistency checks break.
-            ts = await this.validateBlockForSubmission(block, {
+            const attestationData = {
                 digest: digest.toBuffer(),
                 attestations: attestations ?? []
-            });
+            };
+            // TODO(palla): Check whether we're validating twice, once here and once within addProposeTx, since we call simulateProposeTx in both places.
+            ts = await this.validateBlockForSubmission(block, attestationData, opts);
         } catch (err) {
-            this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, undefined, {
+            this.log.error(`Block validation failed. ${err instanceof Error ? err.message : 'No error message'}`, err, {
                 ...block.getStats(),
-                slotNumber: block.header.globalVariables.slotNumber.toBigInt()
+                slotNumber: block.header.globalVariables.slotNumber.toBigInt(),
+                forcePendingBlockNumber: opts.forcePendingBlockNumber
             });
             throw err;
         }
-        this.log.debug(`Submitting propose transaction`);
+        this.log.verbose(`Enqueuing block propose transaction`, {
+            ...block.toBlockInfo(),
+            ...opts
+        });
         await this.addProposeTx(block, proposeTxArgs, opts, ts);
         return true;
     }
+    enqueueInvalidateBlock(request, opts = {}) {
+        if (!request) {
+            return;
+        }
+        // We issue the simulation against the rollup contract, so we need to account for the overhead of the multicall3
+        const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil(Number(request.gasUsed) * 64 / 63)));
+        const logData = {
+            ...pick(request, 'gasUsed', 'blockNumber'),
+            gasLimit,
+            opts
+        };
+        this.log.verbose(`Enqueuing invalidate block request`, logData);
+        this.addRequest({
+            action: `invalidate-by-${request.reason}`,
+            request: request.request,
+            gasConfig: {
+                gasLimit,
+                txTimeoutAt: opts.txTimeoutAt
+            },
+            lastValidL2Slot: this.getCurrentL2Slot() + 2n,
+            checkSuccess: (_req, result)=>{
+                const success = result && result.receipt && result.receipt.status === 'success' && tryExtractEvent(result.receipt.logs, this.rollupContract.address, RollupAbi, 'BlockInvalidated');
+                if (!success) {
+                    this.log.warn(`Invalidate block ${request.blockNumber} failed`, {
+                        ...result,
+                        ...logData
+                    });
+                } else {
+                    this.log.info(`Invalidate block ${request.blockNumber} succeeded`, {
+                        ...result,
+                        ...logData
+                    });
+                }
+                return !!success;
+            }
+        });
+    }
     /**
    * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
    * Be warned, the call may return false even if the tx subsequently gets successfully mined.
@@ -432,7 +602,7 @@ export class SequencerPublisher {
         this.interrupted = false;
         this.l1TxUtils.restart();
     }
-    async prepareProposeTx(encodedData, timestamp) {
+    async prepareProposeTx(encodedData, timestamp, options) {
         if (!this.l1TxUtils.client.account) {
             throw new Error('L1 TX utils needs to be initialized with an account wallet.');
         }
@@ -462,6 +632,7 @@ export class SequencerPublisher {
         });
         const attestations = encodedData.attestations ? encodedData.attestations.map((attest)=>attest.toViem()) : [];
         const txHashes = encodedData.txHashes ? encodedData.txHashes.map((txHash)=>txHash.toString()) : [];
+        const signers = encodedData.attestations?.filter((attest)=>!attest.signature.isEmpty()).map((attest)=>attest.address.toString());
         const args = [
             {
                 header: encodedData.header.toViem(),
@@ -474,9 +645,10 @@ export class SequencerPublisher {
                 txHashes
             },
             RollupContract.packAttestations(attestations),
+            signers ?? [],
             blobInput
         ];
-        const { rollupData, simulationResult } = await this.simulateProposeTx(args, timestamp);
+        const { rollupData, simulationResult } = await this.simulateProposeTx(args, timestamp, options);
         return {
             args,
             blobEvaluationGas,
@@ -489,28 +661,17 @@ export class SequencerPublisher {
    * @param args - The propose tx args
    * @param timestamp - The timestamp to simulate proposal at
    * @returns The simulation result
-   */ async simulateProposeTx(args, timestamp) {
+   */ async simulateProposeTx(args, timestamp, options) {
         const rollupData = encodeFunctionData({
             abi: RollupAbi,
             functionName: 'propose',
             args
         });
-        const forwarderData = encodeFunctionData({
-            abi: multicall3Abi,
-            functionName: 'aggregate3',
-            args: [
-                [
-                    {
-                        target: this.rollupContract.address,
-                        allowFailure: false,
-                        callData: rollupData
-                    }
-                ]
-            ]
-        });
+        // override the pending block number if requested
+        const forcePendingBlockNumberStateDiff = (options.forcePendingBlockNumber !== undefined ? await this.rollupContract.makePendingBlockNumberOverride(options.forcePendingBlockNumber) : []).flatMap((override)=>override.stateDiff ?? []);
         const simulationResult = await this.l1TxUtils.simulate({
-            to: MULTI_CALL_3_ADDRESS,
-            data: forwarderData,
+            to: this.rollupContract.address,
+            data: rollupData,
             gas: SequencerPublisher.PROPOSE_GAS_GUESS
         }, {
             // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
@@ -525,7 +686,8 @@ export class SequencerPublisher {
                     {
                         slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true),
                         value: toPaddedHex(0n, true)
-                    }
+                    },
+                    ...forcePendingBlockNumberStateDiff
                 ]
             }
         ], RollupAbi, {
@@ -543,8 +705,14 @@ export class SequencerPublisher {
     async addProposeTx(block, encodedData, opts = {}, timestamp) {
         const timer = new Timer();
         const kzg = Blob.getViemKzgInstance();
-        const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp);
+        const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp, opts);
         const startBlock = await this.l1TxUtils.getBlockNumber();
+        const gasLimit = this.l1TxUtils.bumpGasLimit(BigInt(Math.ceil(Number(simulationResult.gasUsed) * 64 / 63)) + blobEvaluationGas + SequencerPublisher.MULTICALL_OVERHEAD_GAS_GUESS);
+        // Send the blobs to the blob sink preemptively. This helps in tests where the sequencer mistakingly thinks that the propose
+        // tx fails but it does get mined. We make sure that the blobs are sent to the blob sink regardless of the tx outcome.
+        void this.blobSinkClient.sendBlobsToBlobSink(encodedData.blobs).catch((_err)=>{
+            this.log.error('Failed to send blobs to blob sink');
+        });
         return this.addRequest({
             action: 'propose',
             request: {
@@ -554,18 +722,19 @@ export class SequencerPublisher {
             lastValidL2Slot: block.header.globalVariables.slotNumber.toBigInt(),
             gasConfig: {
                 ...opts,
-                gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult.gasUsed + blobEvaluationGas)
+                gasLimit
             },
             blobConfig: {
                 blobs: encodedData.blobs.map((b)=>b.data),
                 kzg
             },
-            onResult: (request, result)=>{
+            checkSuccess: (request, result)=>{
                 if (!result) {
-                    return;
+                    return false;
                 }
                 const { receipt, stats, errorMsg } = result;
-                if (receipt.status === 'success') {
+                const success = receipt && receipt.status === 'success' && tryExtractEvent(receipt.logs, this.rollupContract.address, RollupAbi, 'L2BlockProposed');
+                if (success) {
                     const endBlock = receipt.blockNumber;
                     const inclusionBlocks = Number(endBlock - startBlock);
                     const publishStats = {
@@ -580,35 +749,24 @@ export class SequencerPublisher {
                         blobCount: encodedData.blobs.length,
                         inclusionBlocks
                     };
-                    this.log.verbose(`Published L2 block to L1 rollup contract`, {
+                    this.log.info(`Published L2 block to L1 rollup contract`, {
                         ...stats,
-                        ...block.getStats()
+                        ...block.getStats(),
+                        ...receipt
                     });
                     this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
-                    // Send the blobs to the blob sink
-                    this.sendBlobsToBlobSink(receipt.blockHash, encodedData.blobs).catch((_err)=>{
-                        this.log.error('Failed to send blobs to blob sink');
-                    });
                     return true;
                 } else {
                     this.metrics.recordFailedTx('process');
-                    this.log.error(`Rollup process tx reverted. ${errorMsg ?? 'No error message'}`, undefined, {
+                    this.log.error(`Rollup process tx failed: ${errorMsg ?? 'no error message'}`, undefined, {
                         ...block.getStats(),
+                        receipt,
                         txHash: receipt.transactionHash,
                         slotNumber: block.header.globalVariables.slotNumber.toBigInt()
                     });
+                    return false;
                 }
             }
         });
     }
-    /**
-   * Send blobs to the blob sink
-   *
-   * If a blob sink url is configured, then we send blobs to the blob sink
-   * - for now we use the blockHash as the identifier for the blobs;
-   *   In the future this will move to be the beacon block id - which takes a bit more work
-   *   to calculate and will need to be mocked in e2e tests
-   */ sendBlobsToBlobSink(blockHash, blobs) {
-        return this.blobSinkClient.sendBlobsToBlobSink(blockHash, blobs);
-    }
 }