@aztec/simulator 0.38.0 → 0.40.0

package/src/avm/opcodes/environment_getters.ts

@@ -1,17 +1,15 @@
-import { type Fr } from '@aztec/circuits.js';
-
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Field, type MemoryValue, Uint64 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { GetterInstruction } from './instruction_impl.js';
 
 abstract class EnvironmentGetterInstruction extends GetterInstruction {
   protected getValue(context: AvmContext): MemoryValue {
-    return new Field(this.getEnvironmentValue(context.environment));
+    return this.getEnvironmentValue(context.environment);
   }
 
-  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): Fr | number | bigint;
+  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): MemoryValue;
 }
 
 export class Address extends EnvironmentGetterInstruction {
@@ -19,7 +17,7 @@ export class Address extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.ADDRESS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.address;
+    return new Field(env.address.toField());
   }
 }
 
@@ -28,7 +26,7 @@ export class StorageAddress extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.storageAddress;
+    return new Field(env.storageAddress.toField());
   }
 }
 
@@ -37,7 +35,7 @@ export class Sender extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.SENDER;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.sender;
+    return new Field(env.sender.toField());
   }
 }
 
@@ -46,7 +44,7 @@ export class FeePerL2Gas extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.feePerL2Gas;
+    return new Field(env.feePerL2Gas);
   }
 }
 
@@ -55,7 +53,7 @@ export class FeePerDAGas extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.feePerDaGas;
+    return new Field(env.feePerDaGas);
   }
 }
 
@@ -64,7 +62,7 @@ export class TransactionFee extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.TRANSACTIONFEE;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.transactionFee;
+    return new Field(env.transactionFee);
   }
 }
 
@@ -73,7 +71,7 @@ export class ChainId extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.CHAINID;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.chainId;
+    return new Field(env.globals.chainId);
   }
 }
 
@@ -82,7 +80,7 @@ export class Version extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.VERSION;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.version;
+    return new Field(env.globals.version);
   }
 }
 
@@ -91,7 +89,7 @@ export class BlockNumber extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.blockNumber;
+    return new Field(env.globals.blockNumber);
   }
 }
 
@@ -100,57 +98,6 @@ export class Timestamp extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.TIMESTAMP;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.timestamp;
+    return new Uint64(env.globals.timestamp.toBigInt());
   }
 }
-
-// export class Coinbase extends EnvironmentGetterInstruction {
-//     static type: string = 'COINBASE';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {coinbase} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, coinbase);
-
-//         this.incrementPc(machineState);
-//     }
-// }
-
-// export class BlockL2GasLimit extends EnvironmentGetterInstruction {
-//     static type: string = 'BLOCKL2GASLIMIT';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {blockL2GasLimit} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, blockL2GasLimit);
-
-//         this.incrementPc(machineState);
-//     }
-// }
-
-// export class BlockDAGasLimit extends EnvironmentGetterInstruction {
-//     static type: string = 'BLOCKDAGASLIMIT';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {blockDAGasLimit} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, blockDAGasLimit);
-
-//         this.incrementPc(machineState);
-//     }
-// }

package/src/avm/opcodes/external_calls.ts

@@ -7,6 +7,7 @@ import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
+import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -99,6 +100,16 @@ abstract class ExternalCall extends Instruction {
 
     const success = !nestedCallResults.reverted;
 
+    // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
+    //               This means that for now, the caller cannot recover from errors.
+    if (!success) {
+      if (!nestedCallResults.revertReason) {
+        throw new Error('A reverted nested call should be assigned a revert reason in the AVM execution loop');
+      }
+      // The nested call's revertReason will be used to track the stack of error causes down to the root.
+      throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
+    }
+
     // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
     // than the specified size in order to prevent that memory to be left with garbage
     const returnData = nestedCallResults.output.slice(0, this.retSize);

package/src/avm/opcodes/index.ts

@@ -2,9 +2,11 @@ export * from './arithmetic.js';
 export * from './bitwise.js';
 export * from './control_flow.js';
 export * from './contract.js';
+export * from './conversion.js';
 export * from './instruction.js';
 export * from './comparators.js';
 export * from './memory.js';
+export * from './misc.js';
 export * from './storage.js';
 export * from './external_calls.js';
 export * from './environment_getters.js';

package/src/avm/opcodes/misc.ts

@@ -0,0 +1,63 @@
+import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
+
+import { type AvmContext } from '../avm_context.js';
+import { TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class DebugLog extends Instruction {
+  static type: string = 'DEBUGLOG';
+  static readonly opcode: Opcode = Opcode.DEBUGLOG;
+  static readonly logger = createDebugLogger('aztec:avm_simulator:debug_log');
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // Opcode
+    OperandType.UINT8, // Indirect
+    OperandType.UINT32, // message memory address
+    OperandType.UINT32, // message size
+    OperandType.UINT32, // fields memory address
+    OperandType.UINT32, // fields size address
+  ];
+
+  constructor(
+    private indirect: number,
+    private messageOffset: number,
+    private messageSize: number,
+    private fieldsOffset: number,
+    private fieldsSizeOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const [messageOffset, fieldsOffset, fieldsSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset],
+      memory,
+    );
+
+    const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
+    memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
+    memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
+
+    const memoryOperations = { reads: 1 + fieldsSize + this.messageSize, writes: 0, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    const rawMessage = memory.getSlice(messageOffset, this.messageSize);
+    const fields = memory.getSlice(fieldsOffset, fieldsSize);
+
+    // Interpret str<N> = [u8; N] to string.
+    const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
+    const formattedStr = applyStringFormatting(
+      messageAsStr,
+      fields.map(field => field.toFr()),
+    );
+
+    DebugLog.logger.verbose(formattedStr);
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/serialization/bytecode_serialization.ts

@@ -11,6 +11,7 @@ import {
   CalldataCopy,
   Cast,
   ChainId,
+  DebugLog,
   Div,
   EmitNoteHash,
   EmitNullifier,
@@ -46,6 +47,7 @@ import {
   StorageAddress,
   Sub,
   Timestamp,
+  ToRadixLE,
   TransactionFee,
   Version,
   Xor,
@@ -131,11 +133,16 @@ const INSTRUCTION_SET = () =>
     [Return.opcode, Return],
     [Revert.opcode, Revert],
 
+    // Misc
+    [DebugLog.opcode, DebugLog],
+
     // //// Gadgets
     [Keccak.opcode, Keccak],
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],
     [Pedersen.opcode, Pedersen],
+    // Conversions
+    [ToRadixLE.opcode, ToRadixLE],
   ]);
 
 interface Serializable {

package/src/avm/serialization/instruction_serialization.ts

@@ -69,11 +69,15 @@ export enum Opcode {
   DELEGATECALL,
   RETURN,
   REVERT,
+  // Misc
+  DEBUGLOG,
   // Gadgets
   KECCAK,
   POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+  // Conversion
+  TORADIXLE,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.

package/src/client/client_execution_context.ts

@@ -24,7 +24,7 @@ import { computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash } fr
 import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, type Point } from '@aztec/foundation/fields';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
 import { type NoteData, toACVMWitness } from '../acvm/index.js';
 import { type PackedValuesCache } from '../common/packed_values_cache.js';
@@ -63,6 +63,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
+  private publicTeardownFunctionCall: PublicCallRequest = PublicCallRequest.empty();
 
   constructor(
     contractAddress: AztecAddress,
@@ -173,6 +174,13 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.enqueuedPublicFunctionCalls;
   }
 
+  /**
+   * Return the public teardown function call set during this execution.
+   */
+  public getPublicTeardownFunctionCall() {
+    return this.publicTeardownFunctionCall;
+  }
+
   /**
    * Pack the given array of arguments.
    * @param args - Arguments to pack
@@ -262,11 +270,11 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     notes.forEach(n => {
       if (n.index !== undefined) {
-        const siloedNoteHash = siloNoteHash(n.contractAddress, n.innerNoteHash);
-        const uniqueSiloedNoteHash = computeUniqueNoteHash(n.nonce, siloedNoteHash);
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
-        // Should always be uniqueSiloedNoteHash when publicly created notes include nonces.
-        const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash;
+        // Should always call computeUniqueNoteHash when publicly created notes include nonces.
+        const uniqueNoteHash = n.nonce.isZero() ? n.innerNoteHash : computeUniqueNoteHash(n.nonce, n.innerNoteHash);
+        const siloedNoteHash = siloNoteHash(n.contractAddress, uniqueNoteHash);
+        const noteHashForReadRequest = siloedNoteHash;
         this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
       }
     });
@@ -465,9 +473,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Creates a PublicCallStackItem object representing the request to call a public function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Creates a PublicCallStackItem object representing the request to call a public function.
    * @param targetContractAddress - The address of the contract to call.
    * @param functionSelector - The function selector of the function to call.
    * @param argsHash - The packed arguments to pass to the function.
@@ -475,7 +481,8 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The public call stack item with the request information.
    */
-  public override async enqueuePublicFunctionCall(
+  protected async createPublicCallRequest(
+    callType: 'enqueued' | 'teardown',
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -494,20 +501,51 @@ export class ClientExecutionContext extends ViewDataOracle {
       isStaticCall,
     );
     const args = this.packedValuesCache.unpack(argsHash);
-    const enqueuedRequest = PublicCallRequest.from({
+
+    // TODO($846): if enqueued public calls are associated with global
+    // side-effect counter, that will leak info about how many other private
+    // side-effects occurred in the TX. Ultimately the private kernel should
+    // just output everything in the proper order without any counters.
+    this.log.verbose(
+      `Created PublicCallRequest of type [${callType}], side-effect counter [${sideEffectCounter}] to ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+    );
+
+    return PublicCallRequest.from({
       args,
       callContext: derivedCallContext,
       parentCallContext: this.callContext,
       functionData: FunctionData.fromAbi(targetArtifact),
       contractAddress: targetContractAddress,
     });
+  }
 
-    // TODO($846): if enqueued public calls are associated with global
-    // side-effect counter, that will leak info about how many other private
-    // side-effects occurred in the TX. Ultimately the private kernel should
-    // just output everything in the proper order without any counters.
-    this.log.verbose(
-      `Enqueued call to public function (with side-effect counter #${sideEffectCounter}) ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+  /**
+   * Creates and enqueues a PublicCallStackItem object representing the request to call a public function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function to call.
+   * @param argsHash - The packed arguments to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The public call stack item with the request information.
+   */
+  public override async enqueuePublicFunctionCall(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+    isDelegateCall: boolean,
+  ): Promise<PublicCallRequest> {
+    const enqueuedRequest = await this.createPublicCallRequest(
+      'enqueued',
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
+      isDelegateCall,
     );
 
     this.enqueuedPublicFunctionCalls.push(enqueuedRequest);
@@ -515,6 +553,40 @@ export class ClientExecutionContext extends ViewDataOracle {
     return enqueuedRequest;
   }
 
+  /**
+   * Creates a PublicCallStackItem and sets it as the public teardown function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function to call.
+   * @param argsHash - The packed arguments to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The public call stack item with the request information.
+   */
+  public override async setPublicTeardownFunctionCall(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+    isDelegateCall: boolean,
+  ): Promise<PublicCallRequest> {
+    const publicTeardownFunctionCall = await this.createPublicCallRequest(
+      'teardown',
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
+      isDelegateCall,
+    );
+
+    this.publicTeardownFunctionCall = publicTeardownFunctionCall;
+
+    return publicTeardownFunctionCall;
+  }
+
   /**
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.
@@ -570,4 +642,8 @@ export class ClientExecutionContext extends ViewDataOracle {
     const aes128 = new Aes128();
     return aes128.encryptBufferCBC(input, initializationVector, key);
   }
+
+  public override debugLog(message: string, fields: Fr[]) {
+    this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
+  }
 }

package/src/client/db_oracle.ts

@@ -8,7 +8,7 @@ import {
 import { type CompleteAddress, type Header } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr, type Point } from '@aztec/foundation/fields';
+import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData, type NullifierKeys } from '../acvm/index.js';
@@ -64,14 +64,6 @@ export interface DBOracle extends CommitmentsDB {
    */
   popCapsule(): Promise<Fr[]>;
 
-  /**
-   * Gets public keys for an address.
-   * @param The address to look up
-   * @returns The public keys for a specific address
-   * TODO(#5834): Replace with `getCompleteAddress`.
-   */
-  getPublicKeysForAddress(address: AztecAddress): Promise<Point[]>;
-
   /**
    * Retrieve nullifier keys associated with a specific account and app/contract address.
    *

package/src/client/execution_result.ts

@@ -5,7 +5,7 @@ import {
   UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { type IsEmpty, type PrivateCallStackItem, type PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -56,6 +56,8 @@ export interface ExecutionResult {
   nestedExecutions: this[];
   /** Enqueued public function execution requests to be picked up by the sequencer. */
   enqueuedPublicFunctionCalls: PublicCallRequest[];
+  /** Public function execution requested for teardown */
+  publicTeardownFunctionCall: PublicCallRequest;
   /**
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
@@ -130,6 +132,23 @@ export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult):
   // as the kernel processes it like a stack, popping items off and pushing them to output
   return [
     ...execResult.enqueuedPublicFunctionCalls,
-    ...[...execResult.nestedExecutions].flatMap(collectEnqueuedPublicFunctionCalls),
+    ...execResult.nestedExecutions.flatMap(collectEnqueuedPublicFunctionCalls),
   ].sort((a, b) => b.callContext.sideEffectCounter - a.callContext.sideEffectCounter);
 }
+
+export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicCallRequest {
+  const teardownCalls = [
+    execResult.publicTeardownFunctionCall,
+    ...execResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCall),
+  ].filter(call => !call.isEmpty());
+
+  if (teardownCalls.length === 1) {
+    return teardownCalls[0];
+  }
+
+  if (teardownCalls.length > 1) {
+    throw new Error('Multiple public teardown calls detected');
+  }
+
+  return PublicCallRequest.empty();
+}

package/src/client/private_execution.ts

@@ -54,6 +54,7 @@ export async function executePrivateFunction(
   const nullifiedNoteHashCounters = context.getNullifiedNoteHashCounters();
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
+  const publicTeardownFunctionCall = context.getPublicTeardownFunctionCall();
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
@@ -68,6 +69,7 @@ export async function executePrivateFunction(
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,
+    publicTeardownFunctionCall,
     encryptedLogs,
     unencryptedLogs,
   };

package/src/client/simulator.ts

@@ -200,7 +200,7 @@ export class AcirSimulator {
       args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
     };
 
-    const [innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier] = (await this.runUnconstrained(
+    const [innerNoteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
       execRequest,
       artifact,
       contractAddress,
@@ -208,8 +208,8 @@ export class AcirSimulator {
 
     return {
       innerNoteHash: new Fr(innerNoteHash),
+      uniqueNoteHash: new Fr(uniqueNoteHash),
       siloedNoteHash: new Fr(siloedNoteHash),
-      uniqueSiloedNoteHash: new Fr(uniqueSiloedNoteHash),
       innerNullifier: new Fr(innerNullifier),
     };
   }
@@ -232,82 +232,4 @@ export class AcirSimulator {
     );
     return innerNoteHash;
   }
-
-  /**
-   * Computes the unique note hash of a note.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeUniqueSiloedNoteHash(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { uniqueSiloedNoteHash } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return uniqueSiloedNoteHash;
-  }
-
-  /**
-   * Computes the siloed note hash of a note.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeSiloedNoteHash(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { siloedNoteHash } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return siloedNoteHash;
-  }
-
-  /**
-   * Computes the inner note hash of a note, which contains storage slot and the custom note hash.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the unique note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeInnerNullifier(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { innerNullifier } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return innerNullifier;
-  }
 }