@aztec/txe 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/rpc_translator.ts

@@ -1,6 +1,7 @@
 import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
 import { Fr, Point } from '@aztec/aztec.js/fields';
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import {
   type IMiscOracle,
   type IPrivateExecutionOracle,
@@ -117,7 +118,7 @@ export class RPCTranslator {
       : undefined;
 
     const anchorBlockNumber = fromSingle(foreignAnchorBlockNumberIsSome).toBool()
-      ? fromSingle(foreignAnchorBlockNumberValue).toNumber()
+      ? BlockNumber(fromSingle(foreignAnchorBlockNumberValue).toNumber())
       : undefined;
 
     const privateContextInputs = await this.stateHandler.enterPrivateState(contractAddress, anchorBlockNumber);
@@ -266,12 +267,7 @@ export class RPCTranslator {
     ]);
   }
 
-  // Since the argument is a slice, noir automatically adds a length field to oracle call.
-  privateStoreInExecutionCache(
-    _foreignLength: ForeignCallSingle,
-    foreignValues: ForeignCallArray,
-    foreignHash: ForeignCallSingle,
-  ) {
+  privateStoreInExecutionCache(foreignValues: ForeignCallArray, foreignHash: ForeignCallSingle) {
     const values = fromArray(foreignValues);
     const hash = fromSingle(foreignHash);
 
@@ -315,7 +311,7 @@ export class RPCTranslator {
   ) {
     const contractAddress = addressFromSingle(foreignContractAddress);
     const startStorageSlot = fromSingle(foreignStartStorageSlot);
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const numberOfElements = fromSingle(foreignNumberOfElements).toNumber();
 
     const values = await this.handlerAsUtility().utilityStorageRead(
@@ -329,7 +325,7 @@ export class RPCTranslator {
   }
 
   async utilityGetPublicDataWitness(foreignBlockNumber: ForeignCallSingle, foreignLeafSlot: ForeignCallSingle) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const leafSlot = fromSingle(foreignLeafSlot);
 
     const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(blockNumber, leafSlot);
@@ -341,6 +337,8 @@ export class RPCTranslator {
   }
 
   async utilityGetNotes(
+    foreignOwnerIsSome: ForeignCallSingle,
+    foreignOwnerValue: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
     foreignNumSelects: ForeignCallSingle,
     foreignSelectByIndexes: ForeignCallArray,
@@ -358,6 +356,10 @@ export class RPCTranslator {
     foreignMaxNotes: ForeignCallSingle,
     foreignPackedRetrievedNoteLength: ForeignCallSingle,
   ) {
+    // Parse Option<AztecAddress>: ownerIsSome is 0 for None, 1 for Some
+    const owner = fromSingle(foreignOwnerIsSome).toBool()
+      ? AztecAddress.fromField(fromSingle(foreignOwnerValue))
+      : undefined;
     const storageSlot = fromSingle(foreignStorageSlot);
     const numSelects = fromSingle(foreignNumSelects).toNumber();
     const selectByIndexes = fromArray(foreignSelectByIndexes).map(fr => fr.toNumber());
@@ -376,6 +378,7 @@ export class RPCTranslator {
     const packedRetrievedNoteLength = fromSingle(foreignPackedRetrievedNoteLength).toNumber();
 
     const noteDatas = await this.handlerAsUtility().utilityGetNotes(
+      owner,
       storageSlot,
       numSelects,
       selectByIndexes,
@@ -392,7 +395,17 @@ export class RPCTranslator {
       status,
     );
 
-    const returnDataAsArrayOfArrays = noteDatas.map(packAsRetrievedNote);
+    const returnDataAsArrayOfArrays = noteDatas.map(noteData =>
+      packAsRetrievedNote({
+        contractAddress: noteData.contractAddress,
+        owner: noteData.owner,
+        randomness: noteData.randomness,
+        storageSlot: noteData.storageSlot,
+        noteNonce: noteData.noteNonce,
+        index: noteData.index,
+        note: noteData.note,
+      }),
+    );
 
     // Now we convert each sub-array to an array of ForeignCallSingles
     const returnDataAsArrayOfForeignCallSingleArrays = returnDataAsArrayOfArrays.map(subArray =>
@@ -410,19 +423,31 @@ export class RPCTranslator {
   }
 
   privateNotifyCreatedNote(
+    foreignOwner: ForeignCallSingle,
     foreignStorageSlot: ForeignCallSingle,
+    foreignRandomness: ForeignCallSingle,
     foreignNoteTypeId: ForeignCallSingle,
     foreignNote: ForeignCallArray,
     foreignNoteHash: ForeignCallSingle,
     foreignCounter: ForeignCallSingle,
   ) {
+    const owner = addressFromSingle(foreignOwner);
     const storageSlot = fromSingle(foreignStorageSlot);
+    const randomness = fromSingle(foreignRandomness);
     const noteTypeId = NoteSelector.fromField(fromSingle(foreignNoteTypeId));
     const note = fromArray(foreignNote);
     const noteHash = fromSingle(foreignNoteHash);
     const counter = fromSingle(foreignCounter).toNumber();
 
-    this.handlerAsPrivate().privateNotifyCreatedNote(storageSlot, noteTypeId, note, noteHash, counter);
+    this.handlerAsPrivate().privateNotifyCreatedNote(
+      owner,
+      storageSlot,
+      randomness,
+      noteTypeId,
+      note,
+      noteHash,
+      counter,
+    );
 
     return toForeignCallResult([]);
   }
@@ -505,7 +530,7 @@ export class RPCTranslator {
     foreignBlockNumber: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const nullifier = fromSingle(foreignNullifier);
 
     const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(blockNumber, nullifier);
@@ -549,6 +574,12 @@ export class RPCTranslator {
     throw new Error('Enqueueing public calls is not supported in TestEnvironment::private_context');
   }
 
+  public async privateIsSideEffectCounterRevertible(foreignSideEffectCounter: ForeignCallSingle) {
+    const sideEffectCounter = fromSingle(foreignSideEffectCounter).toNumber();
+    const isRevertible = await this.handlerAsPrivate().privateIsSideEffectCounterRevertible(sideEffectCounter);
+    return toForeignCallResult([toSingle(new Fr(isRevertible))]);
+  }
+
   async utilityGetUtilityContext() {
     const context = await this.handlerAsUtility().utilityGetUtilityContext();
 
@@ -556,7 +587,7 @@ export class RPCTranslator {
   }
 
   async utilityGetBlockHeader(foreignBlockNumber: ForeignCallSingle) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
 
     const header = await this.handlerAsUtility().utilityGetBlockHeader(blockNumber);
 
@@ -571,7 +602,7 @@ export class RPCTranslator {
     foreignTreeId: ForeignCallSingle,
     foreignLeafValue: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const treeId = fromSingle(foreignTreeId).toNumber();
     const leafValue = fromSingle(foreignLeafValue);
 
@@ -589,7 +620,7 @@ export class RPCTranslator {
     foreignBlockNumber: ForeignCallSingle,
     foreignNullifier: ForeignCallSingle,
   ) {
-    const blockNumber = fromSingle(foreignBlockNumber).toNumber();
+    const blockNumber = BlockNumber(fromSingle(foreignBlockNumber).toNumber());
     const nullifier = fromSingle(foreignNullifier);
 
     const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(blockNumber, nullifier);
@@ -921,7 +952,6 @@ export class RPCTranslator {
     foreignFrom: ForeignCallSingle,
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
-    _foreignArgsLength: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
     foreignArgsHash: ForeignCallSingle,
     foreignIsStaticCall: ForeignCallSingle,
@@ -948,7 +978,6 @@ export class RPCTranslator {
   async txeSimulateUtilityFunction(
     foreignTargetContractAddress: ForeignCallSingle,
     foreignFunctionSelector: ForeignCallSingle,
-    _foreignArgsLength: ForeignCallSingle,
     foreignArgs: ForeignCallArray,
   ) {
     const targetContractAddress = addressFromSingle(foreignTargetContractAddress);
@@ -967,7 +996,6 @@ export class RPCTranslator {
   async txePublicCallNewFlow(
     foreignFrom: ForeignCallSingle,
     foreignAddress: ForeignCallSingle,
-    _foreignLength: ForeignCallSingle,
     foreignCalldata: ForeignCallArray,
     foreignIsStaticCall: ForeignCallSingle,
   ) {

package/src/state_machine/archiver.ts

@@ -1,10 +1,12 @@
 import { ArchiverStoreHelper, KVArchiverDataStore, type PublishedL2Block } from '@aztec/archiver';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block, L2BlockSource, L2Tips, ValidateBlockResult } from '@aztec/stdlib/block';
+import type { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockHeader } from '@aztec/stdlib/tx';
@@ -31,7 +33,7 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    * Gets the number of the latest L2 block processed by the block source implementation.
    * @returns The number of the latest L2 block processed by the block source implementation.
    */
-  public getBlockNumber(): Promise<number> {
+  public getBlockNumber(): Promise<BlockNumber> {
     return this.store.getSynchedL2BlockNumber();
   }
 
@@ -39,7 +41,7 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    * Gets the number of the latest L2 block proven seen by the block source implementation.
    * @returns The number of the latest L2 block proven seen by the block source implementation.
    */
-  public getProvenBlockNumber(): Promise<number> {
+  public getProvenBlockNumber(): Promise<BlockNumber> {
     return this.store.getSynchedL2BlockNumber();
   }
 
@@ -56,7 +58,7 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
     if (number == 0) {
       return undefined;
     }
-    const blocks = await this.store.getPublishedBlocks(number, 1);
+    const blocks = await this.store.getPublishedBlocks(BlockNumber(number), 1);
     return blocks.length === 0 ? undefined : blocks[0];
   }
 
@@ -81,31 +83,43 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
     if (number === 0) {
       return undefined;
     }
-    const headers = await this.store.getBlockHeaders(number, 1);
+    const headers = await this.store.getBlockHeaders(BlockNumber(number), 1);
     return headers.length === 0 ? undefined : headers[0];
   }
 
   public getBlocks(from: number, limit: number, _proven?: boolean): Promise<L2Block[]> {
-    return this.getPublishedBlocks(from, limit).then(blocks => blocks.map(b => b.block));
+    return this.getPublishedBlocks(BlockNumber(from), limit).then(blocks => blocks.map(b => b.block));
   }
 
-  public getL2SlotNumber(): Promise<bigint> {
+  public getPublishedCheckpoints(_from: CheckpointNumber, _limit: number): Promise<PublishedCheckpoint[]> {
+    throw new Error('TXE Archiver does not implement "getPublishedCheckpoints"');
+  }
+
+  public getCheckpointByArchive(_archive: Fr): Promise<Checkpoint | undefined> {
+    throw new Error('TXE Archiver does not implement "getCheckpointByArchive"');
+  }
+
+  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
     throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
   }
 
-  public getL2EpochNumber(): Promise<bigint> {
+  public getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
   }
 
-  public getBlocksForEpoch(_epochNumber: bigint): Promise<L2Block[]> {
+  public getCheckpointsForEpoch(_epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    throw new Error('TXE Archiver does not implement "getCheckpointsForEpoch"');
+  }
+
+  public getBlocksForEpoch(_epochNumber: EpochNumber): Promise<L2Block[]> {
     throw new Error('TXE Archiver does not implement "getBlocksForEpoch"');
   }
 
-  public getBlockHeadersForEpoch(_epochNumber: bigint): Promise<BlockHeader[]> {
+  public getBlockHeadersForEpoch(_epochNumber: EpochNumber): Promise<BlockHeader[]> {
     throw new Error('TXE Archiver does not implement "getBlockHeadersForEpoch"');
   }
 
-  public isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('TXE Archiver does not implement "isEpochComplete"');
   }
 

package/src/state_machine/dummy_p2p_client.ts

@@ -1,3 +1,4 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type {
   AuthRequest,
   ENR,
@@ -17,6 +18,10 @@ import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
 export class DummyP2P implements P2P {
+  public broadcastAttestations(_attestations: BlockAttestation[]): Promise<void> {
+    return Promise.resolve();
+  }
+
   public validate(_txs: Tx[]): Promise<void> {
     return Promise.resolve();
   }
@@ -113,7 +118,7 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getTxsByHash"');
   }
 
-  public getAttestationsForSlot(_slot: bigint, _proposalId?: string): Promise<BlockAttestation[]> {
+  public getAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<BlockAttestation[]> {
     throw new Error('DummyP2P does not implement "getAttestationForSlot"');
   }
 

package/src/state_machine/global_variable_builder.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
@@ -10,10 +11,10 @@ export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
   }
 
   public buildGlobalVariables(
-    _blockNumber: number,
+    _blockNumber: BlockNumber,
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,
-    _slotNumber?: bigint,
+    _slotNumber?: SlotNumber,
   ): Promise<GlobalVariables> {
     return Promise.resolve(makeGlobalVariables());
   }

package/src/state_machine/index.ts

@@ -59,7 +59,7 @@ export class TXEStateMachine {
 
   public async handleL2Block(block: L2Block) {
     await Promise.all([
-      this.synchronizer.handleL2Block(block),
+      this.synchronizer.handleL2Block(block.toL2Block()),
       this.archiver.addBlocks([
         PublishedL2Block.fromFields({
           block,

package/src/state_machine/mock_epoch_cache.ts

@@ -1,4 +1,5 @@
 import type { EpochAndSlot, EpochCacheInterface, EpochCommitteeInfo, SlotTag } from '@aztec/epoch-cache';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 /**
@@ -10,46 +11,46 @@ export class MockEpochCache implements EpochCacheInterface {
     return Promise.resolve({
       committee: undefined,
       seed: 0n,
-      epoch: 0n,
+      epoch: EpochNumber.ZERO,
     });
   }
 
   getEpochAndSlotNow(): EpochAndSlot {
     return {
-      epoch: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
     };
   }
 
   getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
     return {
-      epoch: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
       now: 0n,
     };
   }
 
-  getProposerIndexEncoding(_epoch: bigint, _slot: bigint, _seed: bigint): `0x${string}` {
+  getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
 
-  computeProposerIndex(_slot: bigint, _epoch: bigint, _seed: bigint, _size: bigint): bigint {
+  computeProposerIndex(_slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, _size: bigint): bigint {
     return 0n;
   }
 
   getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
     currentProposer: EthAddress | undefined;
     nextProposer: EthAddress | undefined;
-    currentSlot: bigint;
-    nextSlot: bigint;
+    currentSlot: SlotNumber;
+    nextSlot: SlotNumber;
   }> {
     return Promise.resolve({
       currentProposer: undefined,
       nextProposer: undefined,
-      currentSlot: 0n,
-      nextSlot: 0n,
+      currentSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
     });
   }
 

package/src/state_machine/synchronizer.ts

@@ -1,6 +1,7 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import type { L2Block } from '@aztec/stdlib/block';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
@@ -12,7 +13,7 @@ import { NativeWorldStateService } from '@aztec/world-state/native';
 
 export class TXESynchronizer implements WorldStateSynchronizer {
   // This works when set to 1 as well.
-  private blockNumber = 0;
+  private blockNumber = BlockNumber.ZERO;
 
   constructor(public nativeWorldStateService: NativeWorldStateService) {}
 
@@ -22,7 +23,7 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return new this(nativeWorldStateService);
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2BlockNew) {
     await this.nativeWorldStateService.handleL2BlockAndMessages(
       block,
       Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
@@ -37,7 +38,7 @@ export class TXESynchronizer implements WorldStateSynchronizer {
    * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public syncImmediate(_minBlockNumber?: number, _skipThrowIfTargetNotReached?: boolean): Promise<number> {
+  public syncImmediate(_minBlockNumber?: BlockNumber, _skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber> {
     return Promise.resolve(this.blockNumber);
   }
 
@@ -48,12 +49,12 @@ export class TXESynchronizer implements WorldStateSynchronizer {
 
   /** Forks the world state at the given block number, defaulting to the latest one. */
   public fork(block?: number): Promise<MerkleTreeWriteOperations> {
-    return this.nativeWorldStateService.fork(block);
+    return this.nativeWorldStateService.fork(block ? BlockNumber(block) : undefined);
   }
 
   /** Gets a handle that allows reading the state as it was at the given block number. */
   public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
-    return this.nativeWorldStateService.getSnapshot(blockNumber);
+    return this.nativeWorldStateService.getSnapshot(BlockNumber(blockNumber));
   }
 
   /** Backups the db to the target path. */

package/src/txe_session.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
@@ -25,10 +26,10 @@ import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Body, L2Block } from '@aztec/stdlib/block';
 import { GasSettings } from '@aztec/stdlib/gas';
+import { computeProtocolNullifier } from '@aztec/stdlib/hash';
 import { PrivateContextInputs } from '@aztec/stdlib/kernel';
 import { makeAppendOnlyTreeSnapshot, makeGlobalVariables } from '@aztec/stdlib/testing';
 import { CallContext, GlobalVariables, TxContext } from '@aztec/stdlib/tx';
-import type { UInt32 } from '@aztec/stdlib/types';
 
 import { z } from 'zod';
 
@@ -66,7 +67,7 @@ type SessionState =
   | {
       name: 'PRIVATE';
       nextBlockGlobalVariables: GlobalVariables;
-      txRequestHash: Fr;
+      protocolNullifier: Fr;
       noteCache: ExecutionNoteCache;
       taggingIndexCache: ExecutionTaggingIndexCache;
     }
@@ -101,7 +102,7 @@ export type TXEOracleFunctionName = Exclude<
 export interface TXESessionStateHandler {
   enterTopLevelState(): Promise<void>;
   enterPublicState(contractAddress?: AztecAddress): Promise<void>;
-  enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: UInt32): Promise<PrivateContextInputs>;
+  enterPrivateState(contractAddress?: AztecAddress, anchorBlockNumber?: BlockNumber): Promise<PrivateContextInputs>;
   enterUtilityState(contractAddress?: AztecAddress): Promise<void>;
 }
 
@@ -270,7 +271,7 @@ export class TXESession implements TXESessionStateHandler {
 
   async enterPrivateState(
     contractAddress: AztecAddress = DEFAULT_ADDRESS,
-    anchorBlockNumber?: UInt32,
+    anchorBlockNumber?: BlockNumber,
   ): Promise<PrivateContextInputs> {
     this.exitTopLevelState();
 
@@ -288,14 +289,15 @@ export class TXESession implements TXESessionStateHandler {
     const latestBlock = await this.stateMachine.node.getBlockHeader('latest');
 
     const nextBlockGlobalVariables = makeGlobalVariables(undefined, {
-      blockNumber: latestBlock!.globalVariables.blockNumber + 1,
+      blockNumber: BlockNumber(latestBlock!.globalVariables.blockNumber + 1),
       timestamp: this.nextBlockTimestamp,
       version: this.version,
       chainId: this.chainId,
     });
 
     const txRequestHash = getSingleTxBlockRequestHash(nextBlockGlobalVariables.blockNumber);
-    const noteCache = new ExecutionNoteCache(txRequestHash);
+    const protocolNullifier = await computeProtocolNullifier(txRequestHash);
+    const noteCache = new ExecutionNoteCache(protocolNullifier);
     const taggingIndexCache = new ExecutionTaggingIndexCache();
 
     this.oracleHandler = new PrivateExecutionOracle(
@@ -316,7 +318,7 @@ export class TXESession implements TXESessionStateHandler {
     // difference resides in that the simulator has all information needed in order to run the simulation, while ours
     // will be ongoing as the different oracles will be invoked from the Noir test, until eventually the private
     // execution finishes.
-    this.state = { name: 'PRIVATE', nextBlockGlobalVariables, txRequestHash, noteCache, taggingIndexCache };
+    this.state = { name: 'PRIVATE', nextBlockGlobalVariables, protocolNullifier, noteCache, taggingIndexCache };
     this.logger.debug(`Entered state ${this.state.name}`);
 
     return (this.oracleHandler as PrivateExecutionOracle).getPrivateContextInputs();
@@ -329,7 +331,7 @@ export class TXESession implements TXESessionStateHandler {
     // the test. The block therefore gets the *next* block number and timestamp.
     const latestBlockNumber = (await this.stateMachine.node.getBlockHeader('latest'))!.globalVariables.blockNumber;
     const globalVariables = makeGlobalVariables(undefined, {
-      blockNumber: latestBlockNumber + 1,
+      blockNumber: BlockNumber(latestBlockNumber + 1),
       timestamp: this.nextBlockTimestamp,
       version: this.version,
       chainId: this.chainId,
@@ -392,7 +394,7 @@ export class TXESession implements TXESessionStateHandler {
     // logs (other effects like enqueued public calls don't need to be considered since those are not allowed).
     const txEffect = await makeTxEffect(
       this.state.noteCache,
-      this.state.txRequestHash,
+      this.state.protocolNullifier,
       this.state.nextBlockGlobalVariables.blockNumber,
     );
 

package/src/util/encoding.ts

@@ -1,5 +1,5 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { hexToBuffer } from '@aztec/foundation/string';
 import { type ContractArtifact, ContractArtifactSchema } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';

package/src/util/txe_public_contract_data_source.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractDataProvider } from '@aztec/pxe/server';
 import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -14,11 +15,11 @@ import {
 export class TXEPublicContractDataSource implements ContractDataSource {
   #privateFunctionsRoot: Map<string, Buffer> = new Map();
   constructor(
-    private blockNumber: number,
+    private blockNumber: BlockNumber,
     private contractDataProvider: ContractDataProvider,
   ) {}
 
-  getBlockNumber(): Promise<number> {
+  getBlockNumber(): Promise<BlockNumber> {
     return Promise.resolve(this.blockNumber);
   }
 

package/src/utils/block_creation.ts

@@ -4,8 +4,9 @@ import {
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { L2BlockHeader } from '@aztec/stdlib/block';
 import { makeContentCommitment } from '@aztec/stdlib/testing';
 import { AppendOnlyTreeSnapshot, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
@@ -16,7 +17,7 @@ import { GlobalVariables, TxEffect } from '@aztec/stdlib/tx';
  * @param blockNumber The number for the block in which there is a single transaction.
  * @returns The transaction request hash.
  */
-export function getSingleTxBlockRequestHash(blockNumber: number): Fr {
+export function getSingleTxBlockRequestHash(blockNumber: BlockNumber): Fr {
   return new Fr(blockNumber + 9999); // Why does this need to be a high number? Why do small numbered nullifiers already exist?
 }
 
@@ -58,5 +59,6 @@ export async function makeTXEBlockHeader(
     Fr.ZERO,
     Fr.ZERO,
     Fr.ZERO,
+    Fr.ZERO,
   );
 }

package/src/utils/tx_effect_creation.ts

@@ -1,17 +1,18 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ExecutionNoteCache } from '@aztec/pxe/simulator';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/stdlib/hash';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 
 export async function makeTxEffect(
   noteCache: ExecutionNoteCache,
-  txRequestHash: Fr,
-  txBlockNumber: number,
+  protocolNullifier: Fr,
+  txBlockNumber: BlockNumber,
 ): Promise<TxEffect> {
   const txEffect = TxEffect.empty();
 
-  const { usedTxRequestHashForNonces } = noteCache.finish();
-  const nonceGenerator = usedTxRequestHashForNonces ? txRequestHash : noteCache.getAllNullifiers()[0];
+  const { usedProtocolNullifierForNonces } = noteCache.finish();
+  const nonceGenerator = usedProtocolNullifierForNonces ? protocolNullifier : noteCache.getAllNullifiers()[0];
 
   txEffect.noteHashes = await Promise.all(
     noteCache
@@ -27,8 +28,8 @@ export async function makeTxEffect(
   // Nullifiers are already siloed
   txEffect.nullifiers = noteCache.getAllNullifiers();
 
-  if (usedTxRequestHashForNonces) {
-    txEffect.nullifiers.unshift(txRequestHash);
+  if (usedProtocolNullifierForNonces) {
+    txEffect.nullifiers.unshift(protocolNullifier);
   }
 
   txEffect.txHash = new TxHash(new Fr(txBlockNumber));