@aztec/stdlib 3.0.0-nightly.20251104 → 3.0.0-nightly.20251106

package/dest/zkpassport/index.js

@@ -11,17 +11,15 @@ export class ZkPassportProofParams {
     proof;
     publicInputs;
     committedInputs;
-    committedInputCounts;
     validityPeriodInSeconds;
     domain;
     scope;
-    constructor(devMode, vkeyHash, proof, publicInputs, committedInputs, committedInputCounts, validityPeriodInSeconds, domain, scope){
+    constructor(devMode, vkeyHash, proof, publicInputs, committedInputs, validityPeriodInSeconds, domain, scope){
         this.devMode = devMode;
         this.vkeyHash = vkeyHash;
         this.proof = proof;
         this.publicInputs = publicInputs;
         this.committedInputs = committedInputs;
-        this.committedInputCounts = committedInputCounts;
         this.validityPeriodInSeconds = validityPeriodInSeconds;
         this.domain = domain;
         this.scope = scope;
@@ -36,8 +34,6 @@ export class ZkPassportProofParams {
             this.publicInputs,
             this.committedInputs.length,
             this.committedInputs,
-            this.committedInputCounts.length,
-            this.committedInputCounts,
             this.validityPeriodInSeconds,
             this.domain,
             this.scope
@@ -56,14 +52,14 @@ export class ZkPassportProofParams {
         const publicInputs = Array.from({
             length: Number(publicInputsCount)
         }, ()=>Fr.random());
-        return new ZkPassportProofParams(false, Buffer32.random(), randomBytes(1024), publicInputs, committedInputs, committedInputCounts, BigInt(7 * 24 * 60 * 60), 'sequencer.alpha-testnet.aztec.network', 'personhood');
+        return new ZkPassportProofParams(false, Buffer32.random(), randomBytes(1024), publicInputs, committedInputs, BigInt(7 * 24 * 60 * 60), 'sequencer.alpha-testnet.aztec.network', 'personhood');
     }
     static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new ZkPassportProofParams(reader.readBoolean(), reader.readObject(Buffer32), reader.readBuffer(), reader.readVector(Fr), reader.readBuffer(), reader.readUint256Vector(), reader.readUInt256(), reader.readString(), reader.readString());
+        return new ZkPassportProofParams(reader.readBoolean(), reader.readObject(Buffer32), reader.readBuffer(), reader.readVector(Fr), reader.readBuffer(), reader.readUInt256(), reader.readString(), reader.readString());
     }
     static fromViem(params) {
-        return new ZkPassportProofParams(params.serviceConfig.devMode, Buffer32.fromString(params.proofVerificationData.vkeyHash), Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'), params.proofVerificationData.publicInputs.map((input)=>Fr.fromString(input)), Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'), params.commitments.committedInputCounts, params.serviceConfig.validityPeriodInSeconds, params.serviceConfig.domain, params.serviceConfig.scope);
+        return new ZkPassportProofParams(params.serviceConfig.devMode, Buffer32.fromString(params.proofVerificationData.vkeyHash), Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'), params.proofVerificationData.publicInputs.map((input)=>Fr.fromString(input)), Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'), params.serviceConfig.validityPeriodInSeconds, params.serviceConfig.domain, params.serviceConfig.scope);
     }
     toViem() {
         return {
@@ -79,8 +75,7 @@ export class ZkPassportProofParams {
                 publicInputs: this.publicInputs.map((input)=>input.toString())
             },
             commitments: {
-                committedInputs: `0x${this.committedInputs.toString('hex')}`,
-                committedInputCounts: this.committedInputCounts
+                committedInputs: `0x${this.committedInputs.toString('hex')}`
             }
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "3.0.0-nightly.20251104",
+  "version": "3.0.0-nightly.20251106",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -72,13 +72,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "3.0.0-nightly.20251104",
-    "@aztec/blob-lib": "3.0.0-nightly.20251104",
-    "@aztec/constants": "3.0.0-nightly.20251104",
-    "@aztec/ethereum": "3.0.0-nightly.20251104",
-    "@aztec/foundation": "3.0.0-nightly.20251104",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20251104",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251104",
+    "@aztec/bb.js": "3.0.0-nightly.20251106",
+    "@aztec/blob-lib": "3.0.0-nightly.20251106",
+    "@aztec/constants": "3.0.0-nightly.20251106",
+    "@aztec/ethereum": "3.0.0-nightly.20251106",
+    "@aztec/foundation": "3.0.0-nightly.20251106",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251106",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20251106",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.12.0",
     "json-stringify-deterministic": "1.0.12",

package/src/avm/avm.ts

@@ -5,6 +5,7 @@ import { schemas } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
+import { AllContractDeploymentData, ContractDeploymentData } from '../contract/index.js';
 import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
 import { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
@@ -22,6 +23,7 @@ import {
   TreeSnapshots,
   type Tx,
 } from '../tx/index.js';
+import { WorldStateRevision } from '../world-state/world_state_revision.js';
 import { AvmCircuitPublicInputs } from './avm_circuit_public_inputs.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
@@ -30,6 +32,7 @@ import { serializeWithMessagePack } from './message_pack.js';
 ////////////////////////////////////////////////////////////////////////////
 export class AvmContractClassHint {
   constructor(
+    public readonly hintKey: number,
     public readonly classId: Fr,
     public readonly artifactHash: Fr,
     public readonly privateFunctionsRoot: Fr,
@@ -39,20 +42,22 @@ export class AvmContractClassHint {
   static get schema() {
     return z
       .object({
+        hintKey: z.number().int().nonnegative(),
         classId: schemas.Fr,
         artifactHash: schemas.Fr,
         privateFunctionsRoot: schemas.Fr,
         packedBytecode: schemas.Buffer,
       })
       .transform(
-        ({ classId, artifactHash, privateFunctionsRoot, packedBytecode }) =>
-          new AvmContractClassHint(classId, artifactHash, privateFunctionsRoot, packedBytecode),
+        ({ hintKey, classId, artifactHash, privateFunctionsRoot, packedBytecode }) =>
+          new AvmContractClassHint(hintKey, classId, artifactHash, privateFunctionsRoot, packedBytecode),
       );
   }
 }
 
 export class AvmBytecodeCommitmentHint {
   constructor(
+    public readonly hintKey: number,
     public readonly classId: Fr,
     public readonly commitment: Fr,
   ) {}
@@ -60,15 +65,17 @@ export class AvmBytecodeCommitmentHint {
   static get schema() {
     return z
       .object({
+        hintKey: z.number().int().nonnegative(),
         classId: schemas.Fr,
         commitment: schemas.Fr,
       })
-      .transform(({ classId, commitment }) => new AvmBytecodeCommitmentHint(classId, commitment));
+      .transform(({ hintKey, classId, commitment }) => new AvmBytecodeCommitmentHint(hintKey, classId, commitment));
   }
 }
 
 export class AvmContractInstanceHint {
   constructor(
+    public readonly hintKey: number,
     public readonly address: AztecAddress,
     public readonly salt: Fr,
     public readonly deployer: AztecAddress,
@@ -81,6 +88,7 @@ export class AvmContractInstanceHint {
   static get schema() {
     return z
       .object({
+        hintKey: z.number().int().nonnegative(),
         address: AztecAddress.schema,
         salt: schemas.Fr,
         deployer: AztecAddress.schema,
@@ -91,6 +99,7 @@ export class AvmContractInstanceHint {
       })
       .transform(
         ({
+          hintKey,
           address,
           salt,
           deployer,
@@ -100,6 +109,7 @@ export class AvmContractInstanceHint {
           publicKeys,
         }) =>
           new AvmContractInstanceHint(
+            hintKey,
             address,
             salt,
             deployer,
@@ -112,6 +122,24 @@ export class AvmContractInstanceHint {
   }
 }
 
+export class AvmDebugFunctionNameHint {
+  constructor(
+    public readonly address: AztecAddress,
+    public readonly selector: Fr,
+    public readonly name: string,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        address: AztecAddress.schema,
+        selector: schemas.Fr,
+        name: z.string(),
+      })
+      .transform(({ address, selector, name }) => new AvmDebugFunctionNameHint(address, selector, name));
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////
 // Hints (merkle db)
 ////////////////////////////////////////////////////////////////////////////
@@ -387,6 +415,10 @@ export class AvmRevertCheckpointHint {
   }
 }
 
+export class AvmContractDBCreateCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+export class AvmContractDBCommitCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+export class AvmContractDBRevertCheckpointHint extends AvmCheckpointActionNoStateChangeHint {}
+
 ////////////////////////////////////////////////////////////////////////////
 // Hints (other)
 ////////////////////////////////////////////////////////////////////////////
@@ -395,6 +427,8 @@ export class AvmTxHint {
     public readonly hash: string,
     public readonly gasSettings: GasSettings,
     public readonly effectiveGasFees: GasFees,
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
     public readonly nonRevertibleAccumulatedData: {
       noteHashes: Fr[];
       nullifiers: Fr[];
@@ -420,6 +454,7 @@ export class AvmTxHint {
     const teardownCallRequest = tx.getTeardownPublicCallRequestWithCalldata();
     const gasSettings = tx.data.constants.txContext.gasSettings;
     const effectiveGasFees = computeEffectiveGasFees(gasFees, gasSettings);
+    const allContractDeploymentData = AllContractDeploymentData.fromTx(tx);
 
     // For informational purposes. Assumed quick because it should be cached.
     const txHash = tx.getTxHash();
@@ -428,6 +463,8 @@ export class AvmTxHint {
       txHash.hash.toString(),
       gasSettings,
       effectiveGasFees,
+      allContractDeploymentData.getNonRevertibleContractDeploymentData(),
+      allContractDeploymentData.getRevertibleContractDeploymentData(),
       {
         noteHashes: tx.data.forPublic!.nonRevertibleAccumulatedData.noteHashes.filter(x => !x.isZero()),
         nullifiers: tx.data.forPublic!.nonRevertibleAccumulatedData.nullifiers.filter(x => !x.isZero()),
@@ -451,6 +488,8 @@ export class AvmTxHint {
       '',
       GasSettings.empty(),
       GasFees.empty(),
+      ContractDeploymentData.empty(),
+      ContractDeploymentData.empty(),
       { noteHashes: [], nullifiers: [], l2ToL1Messages: [] },
       { noteHashes: [], nullifiers: [], l2ToL1Messages: [] },
       [],
@@ -467,6 +506,8 @@ export class AvmTxHint {
         hash: z.string(),
         gasSettings: GasSettings.schema,
         effectiveGasFees: GasFees.schema,
+        nonRevertibleContractDeploymentData: ContractDeploymentData.schema,
+        revertibleContractDeploymentData: ContractDeploymentData.schema,
         nonRevertibleAccumulatedData: z.object({
           noteHashes: schemas.Fr.array(),
           nullifiers: schemas.Fr.array(),
@@ -488,6 +529,8 @@ export class AvmTxHint {
           hash,
           gasSettings,
           effectiveGasFees,
+          nonRevertibleContractDeploymentData,
+          revertibleContractDeploymentData,
           nonRevertibleAccumulatedData,
           revertibleAccumulatedData,
           setupEnqueuedCalls,
@@ -500,6 +543,8 @@ export class AvmTxHint {
             hash,
             gasSettings,
             effectiveGasFees,
+            nonRevertibleContractDeploymentData,
+            revertibleContractDeploymentData,
             nonRevertibleAccumulatedData,
             revertibleAccumulatedData,
             setupEnqueuedCalls,
@@ -522,6 +567,7 @@ export class AvmExecutionHints {
     public readonly contractInstances: AvmContractInstanceHint[] = [],
     public readonly contractClasses: AvmContractClassHint[] = [],
     public readonly bytecodeCommitments: AvmBytecodeCommitmentHint[] = [],
+    public readonly debugFunctionNames: AvmDebugFunctionNameHint[] = [],
     // Merkle DB hints.
     public startingTreeRoots: TreeSnapshots = TreeSnapshots.empty(),
     public readonly getSiblingPathHints: AvmGetSiblingPathHint[] = [],
@@ -535,6 +581,9 @@ export class AvmExecutionHints {
     public readonly createCheckpointHints: AvmCreateCheckpointHint[] = [],
     public readonly commitCheckpointHints: AvmCommitCheckpointHint[] = [],
     public readonly revertCheckpointHints: AvmRevertCheckpointHint[] = [],
+    public readonly contractDBCreateCheckpointHints: AvmContractDBCreateCheckpointHint[] = [],
+    public readonly contractDBCommitCheckpointHints: AvmContractDBCommitCheckpointHint[] = [],
+    public readonly contractDBRevertCheckpointHints: AvmContractDBRevertCheckpointHint[] = [],
   ) {}
 
   static empty() {
@@ -550,6 +599,7 @@ export class AvmExecutionHints {
         contractInstances: AvmContractInstanceHint.schema.array(),
         contractClasses: AvmContractClassHint.schema.array(),
         bytecodeCommitments: AvmBytecodeCommitmentHint.schema.array(),
+        debugFunctionNames: AvmDebugFunctionNameHint.schema.array(),
         startingTreeRoots: TreeSnapshots.schema,
         getSiblingPathHints: AvmGetSiblingPathHint.schema.array(),
         getPreviousValueIndexHints: AvmGetPreviousValueIndexHint.schema.array(),
@@ -562,6 +612,9 @@ export class AvmExecutionHints {
         createCheckpointHints: AvmCreateCheckpointHint.schema.array(),
         commitCheckpointHints: AvmCommitCheckpointHint.schema.array(),
         revertCheckpointHints: AvmRevertCheckpointHint.schema.array(),
+        contractDBCreateCheckpointHints: AvmContractDBCreateCheckpointHint.schema.array(),
+        contractDBCommitCheckpointHints: AvmContractDBCommitCheckpointHint.schema.array(),
+        contractDBRevertCheckpointHints: AvmContractDBRevertCheckpointHint.schema.array(),
       })
       .transform(
         ({
@@ -571,6 +624,7 @@ export class AvmExecutionHints {
           contractInstances,
           contractClasses,
           bytecodeCommitments,
+          debugFunctionNames,
           startingTreeRoots,
           getSiblingPathHints,
           getPreviousValueIndexHints,
@@ -583,6 +637,9 @@ export class AvmExecutionHints {
           createCheckpointHints,
           commitCheckpointHints,
           revertCheckpointHints,
+          contractDBCreateCheckpointHints,
+          contractDBCommitCheckpointHints,
+          contractDBRevertCheckpointHints,
         }) =>
           new AvmExecutionHints(
             globalVariables,
@@ -591,6 +648,7 @@ export class AvmExecutionHints {
             contractInstances,
             contractClasses,
             bytecodeCommitments,
+            debugFunctionNames,
             startingTreeRoots,
             getSiblingPathHints,
             getPreviousValueIndexHints,
@@ -603,6 +661,9 @@ export class AvmExecutionHints {
             createCheckpointHints,
             commitCheckpointHints,
             revertCheckpointHints,
+            contractDBCreateCheckpointHints,
+            contractDBCommitCheckpointHints,
+            contractDBRevertCheckpointHints,
           ),
       );
   }
@@ -639,3 +700,39 @@ export class AvmCircuitInputs {
     return jsonParseWithSchema(buf.toString(), this.schema);
   }
 }
+
+export class AvmFastSimulationInputs {
+  constructor(
+    public readonly wsRevision: WorldStateRevision,
+    public tx: AvmTxHint,
+    public globalVariables: GlobalVariables,
+    public protocolContracts: ProtocolContracts,
+  ) {}
+
+  static empty() {
+    return new AvmFastSimulationInputs(
+      WorldStateRevision.empty(),
+      AvmTxHint.empty(),
+      GlobalVariables.empty(),
+      ProtocolContracts.empty(),
+    );
+  }
+
+  static get schema() {
+    return z
+      .object({
+        wsRevision: WorldStateRevision.schema,
+        tx: AvmTxHint.schema,
+        globalVariables: GlobalVariables.schema,
+        protocolContracts: ProtocolContracts.schema,
+      })
+      .transform(
+        ({ wsRevision, tx, globalVariables, protocolContracts }) =>
+          new AvmFastSimulationInputs(wsRevision, tx, globalVariables, protocolContracts),
+      );
+  }
+
+  public serializeWithMessagePack(): Buffer {
+    return serializeWithMessagePack(this);
+  }
+}

package/src/contract/contract_deployment_data.ts

@@ -0,0 +1,108 @@
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+/**
+ * Class containing contract class logs and private logs which are both
+ * relevant for contract registrations and deployments.
+ */
+export class ContractDeploymentData {
+  constructor(
+    public readonly contractClassLogs: ContractClassLog[],
+    public readonly privateLogs: PrivateLog[],
+  ) {}
+
+  public getContractClassLogs(): ContractClassLog[] {
+    return this.contractClassLogs;
+  }
+
+  public getPrivateLogs(): PrivateLog[] {
+    return this.privateLogs;
+  }
+
+  public static from(args: { contractClassLogs: ContractClassLog[]; privateLogs: PrivateLog[] }) {
+    return new ContractDeploymentData(args.contractClassLogs, args.privateLogs);
+  }
+
+  public static empty(): ContractDeploymentData {
+    return new ContractDeploymentData([], []);
+  }
+
+  public static get schema() {
+    return z
+      .object({
+        contractClassLogs: z.array(ContractClassLog.schema),
+        privateLogs: z.array(PrivateLog.schema),
+      })
+      .transform(ContractDeploymentData.from);
+  }
+}
+
+/**
+ * Class containing both revertible and non-revertible registration/deployment data.
+ */
+export class AllContractDeploymentData {
+  constructor(
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
+  ) {}
+
+  public getNonRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.nonRevertibleContractDeploymentData;
+  }
+
+  public getRevertibleContractDeploymentData(): ContractDeploymentData {
+    return this.revertibleContractDeploymentData;
+  }
+
+  /**
+   * Extracts all contract registration/deployment data from a tx separated by revertibility.
+   * This includes contract class logs and private logs.
+   *
+   * This method handles both private-only transactions and transactions with public calls,
+   * properly splitting logs between revertible and non-revertible categories.
+   * @param tx - The transaction to extract data from
+   * @returns The extracted deployment data separated by revertibility
+   */
+  static fromTx(tx: Tx): AllContractDeploymentData {
+    const hasPublicCalls = !!tx.data.forPublic;
+
+    // Extract contract class logs from the tx
+    const allClassLogs = tx.getContractClassLogs();
+    let nonRevertibleClassLogs: ContractClassLog[];
+    let revertibleClassLogs: ContractClassLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract class logs
+      // Split the logs up here based on revertibility
+      nonRevertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ false);
+      revertibleClassLogs = tx.getSplitContractClassLogs(/*revertible=*/ true);
+    } else {
+      // Private-only tx: all logs are non-revertible
+      nonRevertibleClassLogs = allClassLogs;
+      revertibleClassLogs = [];
+    }
+
+    // Extract contract instance logs from the transaction's private logs
+    let nonRevertibleInstanceLogs: PrivateLog[];
+    let revertibleInstanceLogs: PrivateLog[];
+
+    if (hasPublicCalls) {
+      // Transactions with public calls can have both revertible and non-revertible contract instance logs
+      // Split the logs up here based on revertibility
+      nonRevertibleInstanceLogs = tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty());
+    } else {
+      // Private-only tx: use logs from the `forRollup` member of the tx
+      // For private-only txs, all logs are non-revertible
+      nonRevertibleInstanceLogs = tx.data.forRollup!.end.privateLogs.filter(l => !l.isEmpty());
+      revertibleInstanceLogs = [];
+    }
+
+    return new AllContractDeploymentData(
+      new ContractDeploymentData(nonRevertibleClassLogs, nonRevertibleInstanceLogs),
+      new ContractDeploymentData(revertibleClassLogs, revertibleInstanceLogs),
+    );
+  }
+}

package/src/contract/index.ts

@@ -3,6 +3,7 @@ export * from './contract_address.js';
 export * from './contract_class.js';
 export * from './contract_class_metadata.js';
 export * from './contract_class_id.js';
+export * from './contract_deployment_data.js';
 export * from './contract_instance.js';
 export * from './contract_metadata.js';
 export * from './contract_instance_update.js';

package/src/contract/private_function_membership_proof.ts

@@ -101,7 +101,7 @@ export async function createPrivateFunctionMembershipProof(
  * // Compute function leaf and assert it belongs to the private functions tree
  * function_leaf = pedersen([selector as Field, vk_hash], GENERATOR__FUNCTION_LEAF)
  * computed_private_function_tree_root = compute_root(function_leaf, private_function_tree_sibling_path)
- * assert computed_private_function_tree_root == contract_class.private_function_root
+ * assert computed_private_function_tree_root == contract_class.private_functions_root
  *
  * // Compute artifact leaf and assert it belongs to the artifact
  * artifact_function_leaf = sha256(selector, metadata_hash, sha256(bytecode))

package/src/hash/hash.ts

@@ -1,9 +1,9 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { GeneratorIndex, NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
 import { poseidon2Hash, poseidon2HashWithSeparator, sha256ToField } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 
-import type { AztecAddress } from '../aztec-address/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
 
 /**
  * Computes a hash of a given verification key.
@@ -57,6 +57,17 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
   return poseidon2HashWithSeparator([contract, innerNullifier], GeneratorIndex.OUTER_NULLIFIER);
 }
 
+/**
+ * Computes the protocol nullifier, which is the hash of the initial tx request siloed with the null msg sender address.
+ * @param txRequestHash - The hash of the initial tx request.
+ * @returns The siloed value of the protocol nullifier.
+ *
+ * @dev Must match the implementation in noir-protocol-circuits/crates/types/src/hash.nr > compute_protocol_nullifier
+ */
+export function computeProtocolNullifier(txRequestHash: Fr): Promise<Fr> {
+  return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
+}
+
 /**
  * Computes a siloed private log tag, given the contract address and the unsiloed tag.
  * A siloed private log tag effectively namespaces a log to a specific contract.

package/src/interfaces/merkle_tree_operations.ts

@@ -7,7 +7,7 @@ import type { NullifierLeaf } from '../trees/nullifier_leaf.js';
 import type { PublicDataTreeLeaf } from '../trees/public_data_leaf.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { StateReference } from '../tx/state_reference.js';
-import type { WorldStateRevision } from '../world-state/world_state_revision.js';
+import type { WorldStateRevision, WorldStateRevisionWithHandle } from '../world-state/world_state_revision.js';
 
 /**
  * Type alias for the nullifier tree ID.
@@ -136,7 +136,7 @@ export interface MerkleTreeReadOperations {
   /**
    * Gets the current revision.
    */
-  getRevision(): WorldStateRevision;
+  getRevision(): WorldStateRevision | WorldStateRevisionWithHandle;
 
   /**
    * Gets sibling path for a leaf.

package/src/tests/factories.ts

@@ -61,6 +61,7 @@ import {
   AvmContractClassHint,
   AvmContractInstanceHint,
   AvmCreateCheckpointHint,
+  AvmDebugFunctionNameHint,
   AvmExecutionHints,
   AvmGetLeafPreimageHintNullifierTree,
   AvmGetLeafPreimageHintPublicDataTree,
@@ -79,6 +80,7 @@ import { AztecAddress } from '../aztec-address/index.js';
 import { L2BlockHeader } from '../block/index.js';
 import {
   type ContractClassPublic,
+  ContractDeploymentData,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
@@ -118,7 +120,7 @@ import {
   PublicCallRequestArrayLengths,
 } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
-import { ContractClassLogFields } from '../logs/index.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
 import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
@@ -1369,6 +1371,7 @@ export function makeAvmCheckpointActionRevertCheckpointHint(seed = 0): AvmRevert
  */
 export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
   return new AvmContractInstanceHint(
+    seed,
     new AztecAddress(new Fr(seed)),
     new Fr(seed + 0x2),
     new AztecAddress(new Fr(seed + 0x3)),
@@ -1384,19 +1387,28 @@ export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
   );
 }
 
+/**
+ * Makes arbitrary AvmDebugFunctionNameHint.
+ * @param seed - The seed to use for generating the hint.
+ * @returns AvmDebugFunctionNameHint.
+ */
+export function makeAvmDebugFunctionNameHint(seed = 0): AvmDebugFunctionNameHint {
+  return new AvmDebugFunctionNameHint(new AztecAddress(new Fr(seed)), new Fr(seed + 0x2), `function-${seed}`);
+}
+
 /* Makes arbitrary AvmContractClassHint.
  * @param seed - The seed to use for generating the state reference.
  * @returns AvmContractClassHint.
  */
 export function makeAvmContractClassHint(seed = 0): AvmContractClassHint {
   const bytecode = makeBytes(32, seed + 0x5);
-  return new AvmContractClassHint(new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
+  return new AvmContractClassHint(seed, new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
 }
 
 export async function makeAvmBytecodeCommitmentHint(seed = 0): Promise<AvmBytecodeCommitmentHint> {
   const classId = new Fr(seed + 2);
   const bytecode = makeBytes(32, seed + 0x5);
-  return new AvmBytecodeCommitmentHint(classId, await computePublicBytecodeCommitment(bytecode));
+  return new AvmBytecodeCommitmentHint(seed, classId, await computePublicBytecodeCommitment(bytecode));
 }
 
 export async function makePublicCallRequestWithCalldata(seed = 0): Promise<PublicCallRequestWithCalldata> {
@@ -1411,11 +1423,23 @@ export async function makePublicCallRequestWithCalldata(seed = 0): Promise<Publi
   return new PublicCallRequestWithCalldata(publicCallRequest, calldata);
 }
 
+export function makeContractClassLog(seed = 0): ContractClassLog {
+  return new ContractClassLog(makeAztecAddress(seed + 0x1000), makeContractClassLogFields(seed + 0x2000), seed % 20);
+}
+
+export function makeContractDeploymentData(seed = 0): ContractDeploymentData {
+  const contractClassLogs = makeArray(seed % 20, i => makeContractClassLog(i), seed + 0x1000);
+  const privateLogs = makeArray(seed % 20, i => makePrivateLog(i), seed + 0x2000);
+  return new ContractDeploymentData(contractClassLogs, privateLogs);
+}
+
 export async function makeAvmTxHint(seed = 0): Promise<AvmTxHint> {
   return new AvmTxHint(
     `txhash-${seed}`,
     makeGasSettings(),
     makeGasFees(seed + 0x1000),
+    makeContractDeploymentData(seed + 0x2000),
+    makeContractDeploymentData(seed + 0x3000),
     {
       noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
       nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
@@ -1454,6 +1478,7 @@ export async function makeAvmExecutionHints(
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
+    debugFunctionNames: makeArray(baseLength + 5, makeAvmDebugFunctionNameHint, seed + 0x4a00),
     startingTreeRoots: makeTreeSnapshots(seed + 0x4900),
     getSiblingPathHints: makeArray(baseLength + 5, makeAvmGetSiblingPathHint, seed + 0x4b00),
     getPreviousValueIndexHints: makeArray(baseLength + 5, makeAvmGetPreviousValueIndexHint, seed + 0x4d00),
@@ -1488,6 +1513,7 @@ export async function makeAvmExecutionHints(
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,
+    fields.debugFunctionNames,
     fields.startingTreeRoots,
     fields.getSiblingPathHints,
     fields.getPreviousValueIndexHints,