@aztec/sequencer-client 0.62.0 → 0.63.0

package/src/sequencer/sequencer.ts

@@ -1,5 +1,4 @@
 import {
-  type BlockAttestation,
   type EpochProofQuote,
   type L1ToL2MessageSource,
   type L2Block,
@@ -10,11 +9,7 @@ import {
   type TxValidator,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
-import {
-  type AllowedElement,
-  BlockProofError,
-  type WorldStateSynchronizerStatus,
-} from '@aztec/circuit-types/interfaces';
+import type { AllowedElement, Signature, WorldStateSynchronizerStatus } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
 import {
   AppendOnlyTreeSnapshot,
@@ -25,7 +20,6 @@ import {
 } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -44,6 +38,7 @@ import { prettyLogViemErrorMsg } from '../publisher/utils.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { type SequencerConfig } from './config.js';
 import { SequencerMetrics } from './metrics.js';
+import { SequencerState, getSecondsIntoSlot, orderAttestations } from './utils.js';
 
 export type ShouldProposeArgs = {
   pendingTxsCount?: number;
@@ -51,6 +46,20 @@ export type ShouldProposeArgs = {
   processedTxsCount?: number;
 };
 
+export class SequencerTooSlowError extends Error {
+  constructor(
+    public readonly currentState: SequencerState,
+    public readonly proposedState: SequencerState,
+    public readonly maxAllowedTime: number,
+    public readonly currentTime: number,
+  ) {
+    super(
+      `Too far into slot to transition to ${proposedState}. max allowed: ${maxAllowedTime}s, time into slot: ${currentTime}s`,
+    );
+    this.name = 'SequencerTooSlowError';
+  }
+}
+
 /**
  * Sequencer client
  * - Wins a period of time to become the sequencer (depending on finalized protocol).
@@ -72,11 +81,17 @@ export class Sequencer {
   private _feeRecipient = AztecAddress.ZERO;
   private state = SequencerState.STOPPED;
   private allowedInSetup: AllowedElement[] = [];
-  private allowedInTeardown: AllowedElement[] = [];
   private maxBlockSizeInBytes: number = 1024 * 1024;
   private metrics: SequencerMetrics;
   private isFlushing: boolean = false;
 
+  /**
+   * The maximum number of seconds that the sequencer can be into a slot to transition to a particular state.
+   * For example, in order to transition into WAITING_FOR_ATTESTATIONS, the sequencer can be at most 3 seconds into the slot.
+   */
+  protected timeTable!: Record<SequencerState, number>;
+  protected enforceTimeTable: boolean = false;
+
   constructor(
     private publisher: L1Publisher,
     private validatorClient: ValidatorClient | undefined, // During migration the validator client can be inactive
@@ -88,6 +103,8 @@ export class Sequencer {
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private publicProcessorFactory: PublicProcessorFactory,
     private txValidatorFactory: TxValidatorFactory,
+    protected l1GenesisTime: number,
+    private aztecSlotDuration: number,
     telemetry: TelemetryClient,
     private config: SequencerConfig = {},
     private log = createDebugLogger('aztec:sequencer'),
@@ -133,25 +150,42 @@ export class Sequencer {
     if (config.maxBlockSizeInBytes !== undefined) {
       this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
     }
-    // TODO(#5917) remove this. it is no longer needed since we don't need to whitelist functions in teardown
-    if (config.allowedInTeardown) {
-      this.allowedInTeardown = config.allowedInTeardown;
-    }
-    if (config.gerousiaPayload) {
-      this.publisher.setPayload(config.gerousiaPayload);
+    if (config.governanceProposerPayload) {
+      this.publisher.setPayload(config.governanceProposerPayload);
     }
+    this.enforceTimeTable = config.enforceTimeTable === true;
+
+    this.setTimeTable();
 
     // TODO: Just read everything from the config object as needed instead of copying everything into local vars.
     this.config = config;
   }
 
+  private setTimeTable() {
+    const newTimeTable: Record<SequencerState, number> = {
+      [SequencerState.STOPPED]: this.aztecSlotDuration,
+      [SequencerState.IDLE]: this.aztecSlotDuration,
+      [SequencerState.SYNCHRONIZING]: this.aztecSlotDuration,
+      [SequencerState.PROPOSER_CHECK]: this.aztecSlotDuration, // We always want to allow the full slot to check if we are the proposer
+      [SequencerState.WAITING_FOR_TXS]: 3,
+      [SequencerState.CREATING_BLOCK]: 5,
+      [SequencerState.PUBLISHING_BLOCK_TO_PEERS]: 5 + this.maxTxsPerBlock * 2, // if we take 5 seconds to create block, then 4 transactions at 2 seconds each
+      [SequencerState.WAITING_FOR_ATTESTATIONS]: 5 + this.maxTxsPerBlock * 2 + 3, // it shouldn't take 3 seconds to publish to peers
+      [SequencerState.PUBLISHING_BLOCK]: 5 + this.maxTxsPerBlock * 2 + 3 + 5, // wait 5 seconds for attestations
+    };
+    if (this.enforceTimeTable && newTimeTable[SequencerState.PUBLISHING_BLOCK] > this.aztecSlotDuration) {
+      throw new Error('Sequencer cannot publish block in less than a slot');
+    }
+    this.timeTable = newTimeTable;
+  }
+
   /**
-   * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
+   * Starts the sequencer and moves to IDLE state.
    */
   public start() {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
     this.runningPromise.start();
-    this.state = SequencerState.IDLE;
+    this.setState(SequencerState.IDLE, true /** force */);
     this.log.info('Sequencer started');
     return Promise.resolve();
   }
@@ -163,7 +197,7 @@ export class Sequencer {
     this.log.debug(`Stopping sequencer`);
     await this.runningPromise?.stop();
     this.publisher.interrupt();
-    this.state = SequencerState.STOPPED;
+    this.setState(SequencerState.STOPPED, true /** force */);
     this.log.info('Stopped sequencer');
   }
 
@@ -174,7 +208,7 @@ export class Sequencer {
     this.log.info('Restarting sequencer');
     this.publisher.restart();
     this.runningPromise!.start();
-    this.state = SequencerState.IDLE;
+    this.setState(SequencerState.IDLE, true /** force */);
   }
 
   /**
@@ -193,7 +227,8 @@ export class Sequencer {
    *          - Submit block
    *          - If our block for some reason is not included, revert the state
    */
-  protected async work() {
+  protected async doRealWork() {
+    this.setState(SequencerState.SYNCHRONIZING);
     // Update state when the previous block has been synced
     const prevBlockSynced = await this.isBlockSynced();
     // Do not go forward with new block if the previous one has not been mined and processed
@@ -202,10 +237,9 @@ export class Sequencer {
       return;
     }
 
-    if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
-      this.log.debug(`Block has been synced`);
-      this.state = SequencerState.IDLE;
-    }
+    this.log.debug('Previous block has been mined and processed');
+
+    this.setState(SequencerState.PROPOSER_CHECK);
 
     const chainTip = await this.l2BlockSource.getBlock(-1);
     const historicalHeader = chainTip?.header;
@@ -240,7 +274,7 @@ export class Sequencer {
       return;
     }
 
-    this.state = SequencerState.WAITING_FOR_TXS;
+    this.setState(SequencerState.WAITING_FOR_TXS);
 
     // Get txs to build the new block.
     const pendingTxs = this.p2pClient.getTxs('pending');
@@ -283,13 +317,24 @@ export class Sequencer {
       //        be in for a world of pain.
       await this.buildBlockAndAttemptToPublish(validTxs, proposalHeader, historicalHeader);
     } catch (err) {
-      if (BlockProofError.isBlockProofError(err)) {
-        const txHashes = err.txHashes.filter(h => !h.isZero());
-        this.log.warn(`Proving block failed, removing ${txHashes.length} txs from pool`);
-        await this.p2pClient.deleteTxs(txHashes);
-      }
       this.log.error(`Error assembling block`, (err as any).stack);
     }
+    this.setState(SequencerState.IDLE);
+  }
+
+  protected async work() {
+    try {
+      await this.doRealWork();
+    } catch (err) {
+      if (err instanceof SequencerTooSlowError) {
+        this.log.warn(err.message);
+      } else {
+        // Re-throw other errors
+        throw err;
+      }
+    } finally {
+      this.setState(SequencerState.IDLE);
+    }
   }
 
   /** Whether to skip the check of min txs per block if more than maxSecondsBetweenBlocks has passed since the previous block. */
@@ -312,7 +357,7 @@ export class Sequencer {
         throw new Error(msg);
       }
 
-      this.log.debug(`Can propose block ${proposalBlockNumber} at slot ${slot}`);
+      this.log.verbose(`Can propose block ${proposalBlockNumber} at slot ${slot}`);
       return slot;
     } catch (err) {
       const msg = prettyLogViemErrorMsg(err);
@@ -323,6 +368,44 @@ export class Sequencer {
     }
   }
 
+  doIHaveEnoughTimeLeft(proposedState: SequencerState, secondsIntoSlot: number): boolean {
+    if (!this.enforceTimeTable) {
+      return true;
+    }
+
+    if (this.timeTable[proposedState] === this.aztecSlotDuration) {
+      return true;
+    }
+
+    const bufferSeconds = this.timeTable[proposedState] - secondsIntoSlot;
+    this.metrics.recordStateTransitionBufferMs(bufferSeconds * 1000, proposedState);
+
+    if (bufferSeconds < 0) {
+      this.log.warn(
+        `Too far into slot to transition to ${proposedState}. max allowed: ${this.timeTable[proposedState]}s, time into slot: ${secondsIntoSlot}s`,
+      );
+      return false;
+    }
+    this.log.debug(
+      `Enough time to transition to ${proposedState}, max allowed: ${this.timeTable[proposedState]}s, time into slot: ${secondsIntoSlot}s`,
+    );
+    return true;
+  }
+
+  setState(proposedState: SequencerState, force: boolean = false) {
+    if (this.state === SequencerState.STOPPED && force !== true) {
+      this.log.warn(
+        `Cannot set sequencer from ${this.state} to ${proposedState} as it is stopped. Set force=true to override.`,
+      );
+      return;
+    }
+    const secondsIntoSlot = getSecondsIntoSlot(this.l1GenesisTime, this.aztecSlotDuration);
+    if (!this.doIHaveEnoughTimeLeft(proposedState, secondsIntoSlot)) {
+      throw new SequencerTooSlowError(this.state, proposedState, this.timeTable[proposedState], secondsIntoSlot);
+    }
+    this.state = proposedState;
+  }
+
   shouldProposeBlock(historicalHeader: Header | undefined, args: ShouldProposeArgs): boolean {
     if (this.isFlushing) {
       this.log.verbose(`Flushing all pending txs in new block`);
@@ -413,7 +496,7 @@ export class Sequencer {
 
     this.metrics.recordNewBlock(newGlobalVariables.blockNumber.toNumber(), validTxs.length);
     const workTimer = new Timer();
-    this.state = SequencerState.CREATING_BLOCK;
+    this.setState(SequencerState.CREATING_BLOCK);
     this.log.info(
       `Building blockNumber=${newGlobalVariables.blockNumber.toNumber()} txCount=${
         validTxs.length
@@ -430,16 +513,23 @@ export class Sequencer {
     const numRealTxs = validTxs.length;
     const blockSize = Math.max(2, numRealTxs);
 
-    const fork = await this.worldState.fork();
+    // NB: separating the dbs because both should update the state
+    const publicProcessorFork = await this.worldState.fork();
+    const orchestratorFork = await this.worldState.fork();
     try {
       // We create a fresh processor each time to reset any cached state (eg storage writes)
-      const processor = this.publicProcessorFactory.create(fork, historicalHeader, newGlobalVariables);
+      const processor = this.publicProcessorFactory.create(publicProcessorFork, historicalHeader, newGlobalVariables);
       const blockBuildingTimer = new Timer();
-      const blockBuilder = this.blockBuilderFactory.create(fork);
+      const blockBuilder = this.blockBuilderFactory.create(orchestratorFork);
       await blockBuilder.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages);
 
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, blockBuilder, this.txValidatorFactory.validatorForProcessedTxs(fork)),
+        processor.process(
+          validTxs,
+          blockSize,
+          blockBuilder,
+          this.txValidatorFactory.validatorForProcessedTxs(publicProcessorFork),
+        ),
       );
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
@@ -510,7 +600,8 @@ export class Sequencer {
         throw err;
       }
     } finally {
-      await fork.close();
+      await publicProcessorFork.close();
+      await orchestratorFork.close();
     }
   }
 
@@ -545,11 +636,11 @@ export class Sequencer {
     this.log.verbose('Creating block proposal');
     const proposal = await this.validatorClient.createBlockProposal(block.header, block.archive.root, txHashes);
 
-    this.state = SequencerState.PUBLISHING_BLOCK_TO_PEERS;
+    this.setState(SequencerState.PUBLISHING_BLOCK_TO_PEERS);
     this.log.verbose('Broadcasting block proposal to validators');
     this.validatorClient.broadcastBlockProposal(proposal);
 
-    this.state = SequencerState.WAITING_FOR_ATTESTATIONS;
+    this.setState(SequencerState.WAITING_FOR_ATTESTATIONS);
     const attestations = await this.validatorClient.collectAttestations(proposal, numberOfRequiredAttestations);
     this.log.verbose(`Collected attestations from validators, number of attestations: ${attestations.length}`);
 
@@ -607,7 +698,7 @@ export class Sequencer {
     proofQuote?: EpochProofQuote,
   ) {
     // Publishes new block to the network and awaits the tx to be mined
-    this.state = SequencerState.PUBLISHING_BLOCK;
+    this.setState(SequencerState.PUBLISHING_BLOCK);
 
     const publishedL2Block = await this.publisher.proposeL2Block(block, attestations, txHashes, proofQuote);
     if (!publishedL2Block) {
@@ -693,64 +784,3 @@ export class Sequencer {
 /**
  * State of the sequencer.
  */
-export enum SequencerState {
-  /**
-   * Will move to WAITING_FOR_TXS after a configured amount of time.
-   */
-  IDLE,
-  /**
-   * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to IDLE otherwise.
-   */
-  WAITING_FOR_TXS,
-  /**
-   * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
-   */
-  CREATING_BLOCK,
-  /**
-   * Publishing blocks to validator peers. Will move to WAITING_FOR_ATTESTATIONS.
-   */
-  PUBLISHING_BLOCK_TO_PEERS,
-  /**
-   * The block has been published to peers, and we are waiting for attestations. Will move to PUBLISHING_CONTRACT_DATA.
-   */
-  WAITING_FOR_ATTESTATIONS,
-  /**
-   * Sending the tx to L1 with encrypted logs and awaiting it to be mined. Will move back to PUBLISHING_BLOCK once finished.
-   */
-  PUBLISHING_CONTRACT_DATA,
-  /**
-   * Sending the tx to L1 with the L2 block data and awaiting it to be mined. Will move to IDLE.
-   */
-  PUBLISHING_BLOCK,
-  /**
-   * Sequencer is stopped and not processing any txs from the pool.
-   */
-  STOPPED,
-}
-
-/** Order Attestations
- *
- * Returns attestation signatures in the order of a series of provided ethereum addresses
- * The rollup smart contract expects attestations to appear in the order of the committee
- *
- * @todo: perform this logic within the memory attestation store instead?
- */
-function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Signature[] {
-  // Create a map of sender addresses to BlockAttestations
-  const attestationMap = new Map<string, BlockAttestation>();
-
-  for (const attestation of attestations) {
-    const sender = attestation.getSender();
-    if (sender) {
-      attestationMap.set(sender.toString(), attestation);
-    }
-  }
-
-  // Create the ordered array based on the orderAddresses, else return an empty signature
-  const orderedAttestations = orderAddresses.map(address => {
-    const addressString = address.toString();
-    return attestationMap.get(addressString)?.signature || Signature.empty();
-  });
-
-  return orderedAttestations;
-}

package/src/sequencer/utils.ts

@@ -0,0 +1,78 @@
+import type { BlockAttestation, EthAddress } from '@aztec/circuit-types';
+import { Signature } from '@aztec/foundation/eth-signature';
+
+export enum SequencerState {
+  /**
+   * Sequencer is stopped and not processing any txs from the pool.
+   */
+  STOPPED = 'STOPPED',
+  /**
+   * Sequencer is awaiting the next call to work().
+   */
+  IDLE = 'IDLE',
+  /**
+   * Synchronizing with the L2 chain.
+   */
+  SYNCHRONIZING = 'SYNCHRONIZING',
+  /**
+   * Checking if we are the proposer for the current slot.
+   */
+  PROPOSER_CHECK = 'PROPOSER_CHECK',
+  /**
+   * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+   */
+  WAITING_FOR_TXS = 'WAITING_FOR_TXS',
+  /**
+   * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
+   */
+  CREATING_BLOCK = 'CREATING_BLOCK',
+  /**
+   * Publishing blocks to validator peers. Will move to WAITING_FOR_ATTESTATIONS.
+   */
+  PUBLISHING_BLOCK_TO_PEERS = 'PUBLISHING_BLOCK_TO_PEERS',
+  /**
+   * The block has been published to peers, and we are waiting for attestations. Will move to PUBLISHING_CONTRACT_DATA.
+   */
+  WAITING_FOR_ATTESTATIONS = 'WAITING_FOR_ATTESTATIONS',
+  /**
+   * Sending the tx to L1 with the L2 block data and awaiting it to be mined. Will move to SYNCHRONIZING.
+   */
+  PUBLISHING_BLOCK = 'PUBLISHING_BLOCK',
+}
+
+export type SequencerStateCallback = () => SequencerState;
+
+export function sequencerStateToNumber(state: SequencerState): number {
+  return Object.values(SequencerState).indexOf(state);
+}
+
+/** Order Attestations
+ *
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ *
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Signature[] {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, BlockAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = attestation.getSender();
+    if (sender) {
+      attestationMap.set(sender.toString(), attestation);
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty signature
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString)?.signature || Signature.empty();
+  });
+
+  return orderedAttestations;
+}
+
+export function getSecondsIntoSlot(l1GenesisTime: number, aztecSlotDuration: number): number {
+  return (Date.now() / 1000 - l1GenesisTime) % aztecSlotDuration;
+}

package/src/tx_validator/gas_validator.ts

@@ -1,7 +1,7 @@
-import { PublicKernelPhase, type Tx, type TxValidator } from '@aztec/circuit-types';
+import { type Tx, TxExecutionPhase, type TxValidator } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, FunctionSelector } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { EnqueuedCallsProcessor, computeFeePayerBalanceStorageSlot } from '@aztec/simulator';
+import { computeFeePayerBalanceStorageSlot, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 /** Provides a view into public contract state */
 export interface PublicStateSource {
@@ -58,7 +58,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     );
 
     // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
-    const setupFns = EnqueuedCallsProcessor.getExecutionRequestsByPhase(tx, PublicKernelPhase.SETUP);
+    const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
     const claimFunctionCall = setupFns.find(
       fn =>
         fn.callContext.contractAddress.equals(this.#feeJuiceAddress) &&
@@ -66,7 +66,7 @@ export class GasTxValidator implements TxValidator<Tx> {
         fn.args.length > 2 &&
         // Public functions get routed through the dispatch function, whose first argument is the target function selector.
         fn.args[0].equals(FunctionSelector.fromSignature('_increase_public_balance((Field),Field)').toField()) &&
-        fn.args[1].equals(feePayer) &&
+        fn.args[1].equals(feePayer.toField()) &&
         !fn.callContext.isStaticCall,
     );
 

package/src/tx_validator/phases_validator.ts

@@ -1,13 +1,13 @@
 import {
   type AllowedElement,
   type PublicExecutionRequest,
-  PublicKernelPhase,
   Tx,
+  TxExecutionPhase,
   type TxValidator,
 } from '@aztec/circuit-types';
 import { type ContractDataSource } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { ContractsDataSourcePublicDB, EnqueuedCallsProcessor } from '@aztec/simulator';
+import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator';
 
 export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
@@ -45,7 +45,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       return true;
     }
 
-    const setupFns = EnqueuedCallsProcessor.getExecutionRequestsByPhase(tx, PublicKernelPhase.SETUP);
+    const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
     for (const setupFn of setupFns) {
       if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
         this.#log.warn(

package/src/tx_validator/test_utils.ts

@@ -7,7 +7,7 @@ export function patchNonRevertibleFn(
   index: number,
   overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
 ): { address: AztecAddress; selector: FunctionSelector } {
-  return patchFn('endNonRevertibleData', tx, index, overrides);
+  return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
 }
 
 export function patchRevertibleFn(
@@ -15,11 +15,11 @@ export function patchRevertibleFn(
   index: number,
   overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
 ): { address: AztecAddress; selector: FunctionSelector } {
-  return patchFn('end', tx, index, overrides);
+  return patchFn('revertibleAccumulatedData', tx, index, overrides);
 }
 
 function patchFn(
-  where: 'end' | 'endNonRevertibleData',
+  where: 'revertibleAccumulatedData' | 'nonRevertibleAccumulatedData',
   tx: Tx,
   index: number,
   overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
@@ -31,11 +31,13 @@ function patchFn(
   fn.callContext.msgSender = overrides.msgSender ?? fn.callContext.msgSender;
   tx.enqueuedPublicFunctionCalls[index] = fn;
 
-  const request = tx.data.forPublic![where].publicCallStack[index];
-  request.callContext.contractAddress = fn.callContext.contractAddress;
-  request.callContext = fn.callContext;
+  const request = tx.data.forPublic![where].publicCallRequests[index];
+  request.contractAddress = fn.callContext.contractAddress;
+  request.msgSender = fn.callContext.msgSender;
+  request.functionSelector = fn.callContext.functionSelector;
+  request.isStaticCall = fn.callContext.isStaticCall;
   request.argsHash = computeVarArgsHash(fn.args);
-  tx.data.forPublic![where].publicCallStack[index] = request;
+  tx.data.forPublic![where].publicCallRequests[index] = request;
 
   return {
     address: fn.callContext.contractAddress,