@aztec/simulator 0.26.6 → 0.27.1

package/src/avm/avm_execution_environment.ts

@@ -36,12 +36,19 @@ export class AvmExecutionEnvironment {
 
     public readonly calldata: Fr[],
 
+    // Function selector is temporary since eventually public contract bytecode will be one blob
+    // containing all functions, and function selector will become an application-level mechanism
+    // (e.g. first few bytes of calldata + compiler-generated jump table)
     public readonly temporaryFunctionSelector: FunctionSelector,
   ) {}
 
-  public deriveEnvironmentForNestedCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       /*storageAddress=*/ address,
       this.origin,
       this.sender,
@@ -53,14 +60,18 @@ export class AvmExecutionEnvironment {
       this.globals,
       this.isStaticCall,
       this.isDelegateCall,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 
-  public deriveEnvironmentForNestedStaticCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedStaticCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       /*storageAddress=*/ address,
       this.origin,
       this.sender,
@@ -72,14 +83,18 @@ export class AvmExecutionEnvironment {
       this.globals,
       /*isStaticCall=*/ true,
       this.isDelegateCall,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 
-  public newDelegateCall(address: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public newDelegateCall(
+    address: AztecAddress,
+    calldata: Fr[],
+    temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      /*address=*/ address,
+      address,
       this.storageAddress,
       this.origin,
       this.sender,
@@ -91,8 +106,8 @@ export class AvmExecutionEnvironment {
       this.globals,
       this.isStaticCall,
       /*isDelegateCall=*/ true,
-      /*calldata=*/ calldata,
-      this.temporaryFunctionSelector,
+      calldata,
+      temporaryFunctionSelector,
     );
   }
 }

package/src/avm/avm_memory_types.ts

@@ -1,5 +1,6 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
@@ -28,6 +29,10 @@ export abstract class MemoryValue {
   public toFr(): Fr {
     return new Fr(this.toBigInt());
   }
+
+  public toString(): string {
+    return `${this.constructor.name}(0x${this.toBigInt().toString(16)})`;
+  }
 }
 
 /** IntegralValue gathers the common operations for all integral memory types. */
@@ -189,6 +194,8 @@ export enum TypeTag {
 
 // TODO: Consider automatic conversion when getting undefined values.
 export class TaggedMemory {
+  static readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:memory');
+
   // FIXME: memory should be 2^32, but TS doesn't allow for arrays that big.
   static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 2n);
   private _mem: MemoryValue[];
@@ -200,25 +207,29 @@ export class TaggedMemory {
 
   public get(offset: number): MemoryValue {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
-    return this.getAs<MemoryValue>(offset);
+    const value = this.getAs<MemoryValue>(offset);
+    return value;
   }
 
   public getAs<T>(offset: number): T {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
+    TaggedMemory.log(`get(${offset}) = ${word}`);
     return word as T;
   }
 
   public getSlice(offset: number, size: number): MemoryValue[] {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
-    return this._mem.slice(offset, offset + size);
+    const value = this._mem.slice(offset, offset + size);
+    TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    return value;
   }
 
   public getSliceAs<T>(offset: number, size: number): T[] {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
-    return this._mem.slice(offset, offset + size) as T[];
+    return this.getSlice(offset, size) as T[];
   }
 
   public getSliceTags(offset: number, size: number): TypeTag[] {
@@ -230,6 +241,7 @@ export class TaggedMemory {
   public set(offset: number, v: MemoryValue) {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem[offset] = v;
+    TaggedMemory.log(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
@@ -240,6 +252,7 @@ export class TaggedMemory {
       this._mem.length = offset + vs.length;
     }
     this._mem.splice(offset, vs.length, ...vs);
+    TaggedMemory.log(`setSlice(${offset}, ${vs})`);
   }
 
   public getTag(offset: number): TypeTag {
@@ -327,4 +340,24 @@ export class TaggedMemory {
         throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
     }
   }
+
+  // Does not truncate. Type constructor will check that it fits.
+  public static buildFromTagOrDie(v: bigint | number, tag: TypeTag): MemoryValue {
+    switch (tag) {
+      case TypeTag.UINT8:
+        return new Uint8(v);
+      case TypeTag.UINT16:
+        return new Uint16(v);
+      case TypeTag.UINT32:
+        return new Uint32(v);
+      case TypeTag.UINT64:
+        return new Uint64(v);
+      case TypeTag.UINT128:
+        return new Uint128(v);
+      case TypeTag.FIELD:
+        return new Field(v);
+      default:
+        throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
+    }
+  }
 }

package/src/avm/avm_simulator.ts

@@ -9,9 +9,13 @@ import type { Instruction } from './opcodes/index.js';
 import { decodeFromBytecode } from './serialization/bytecode_serialization.js';
 
 export class AvmSimulator {
-  private log: DebugLogger = createDebugLogger('aztec:avm_simulator');
+  private log: DebugLogger;
 
-  constructor(private context: AvmContext) {}
+  constructor(private context: AvmContext) {
+    this.log = createDebugLogger(
+      `aztec:avm_simulator:core(f:${context.environment.temporaryFunctionSelector.toString()})`,
+    );
+  }
 
   /**
    * Fetch the bytecode and execute it in the current context.
@@ -52,7 +56,10 @@ export class AvmSimulator {
       // continuing until the machine state signifies a halt
       while (!this.context.machineState.halted) {
         const instruction = instructions[this.context.machineState.pc];
-        assert(!!instruction); // This should never happen
+        assert(
+          !!instruction,
+          'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
+        );
 
         this.log.debug(`@${this.context.machineState.pc} ${instruction.toString()}`);
         // Execute the instruction.

package/src/avm/opcodes/arithmetic.ts

@@ -11,6 +11,8 @@ export class Add extends ThreeOperandInstruction {
   }
 
   async execute(context: AvmContext): Promise<void> {
+    context.machineState.memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+
     const a = context.machineState.memory.get(this.aOffset);
     const b = context.machineState.memory.get(this.bOffset);
 

package/src/avm/opcodes/comparators.ts

@@ -1,4 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
+import { TaggedMemory } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
 
@@ -16,8 +17,7 @@ export class Eq extends ThreeOperandInstruction {
     const a = context.machineState.memory.get(this.aOffset);
     const b = context.machineState.memory.get(this.bOffset);
 
-    // Result will be of the same type as 'a'.
-    const dest = a.build(a.equals(b) ? 1n : 0n);
+    const dest = TaggedMemory.buildFromTagOrDie(a.equals(b) ? 1n : 0n, this.inTag);
     context.machineState.memory.set(this.dstOffset, dest);
 
     context.machineState.incrementPc();
@@ -38,8 +38,7 @@ export class Lt extends ThreeOperandInstruction {
     const a = context.machineState.memory.get(this.aOffset);
     const b = context.machineState.memory.get(this.bOffset);
 
-    // Result will be of the same type as 'a'.
-    const dest = a.build(a.lt(b) ? 1n : 0n);
+    const dest = TaggedMemory.buildFromTagOrDie(a.lt(b) ? 1n : 0n, this.inTag);
     context.machineState.memory.set(this.dstOffset, dest);
 
     context.machineState.incrementPc();
@@ -60,8 +59,7 @@ export class Lte extends ThreeOperandInstruction {
     const a = context.machineState.memory.get(this.aOffset);
     const b = context.machineState.memory.get(this.bOffset);
 
-    // Result will be of the same type as 'a'.
-    const dest = a.build(a.equals(b) || a.lt(b) ? 1n : 0n);
+    const dest = TaggedMemory.buildFromTagOrDie(a.lt(b) || a.equals(b) ? 1n : 0n, this.inTag);
     context.machineState.memory.set(this.dstOffset, dest);
 
     context.machineState.incrementPc();

package/src/avm/opcodes/control_flow.ts

@@ -4,52 +4,6 @@ import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 
-export class Return extends Instruction {
-  static type: string = 'RETURN';
-  static readonly opcode: Opcode = Opcode.RETURN;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(private indirect: number, private returnOffset: number, private copySize: number) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const output = context.machineState.memory.getSlice(this.returnOffset, this.copySize).map(word => word.toFr());
-
-    context.machineState.return(output);
-  }
-}
-
-export class Revert extends Instruction {
-  static type: string = 'RETURN';
-  static readonly opcode: Opcode = Opcode.REVERT;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(private indirect: number, private returnOffset: number, private retSize: number) {
-    super();
-  }
-
-  async execute(context: AvmContext): Promise<void> {
-    const output = context.machineState.memory
-      .getSlice(this.returnOffset, this.returnOffset + this.retSize)
-      .map(word => word.toFr());
-
-    context.machineState.revert(output);
-  }
-}
-
 export class Jump extends Instruction {
   static type: string = 'JUMP';
   static readonly opcode: Opcode = Opcode.JUMP;
@@ -122,7 +76,7 @@ export class InternalReturn extends Instruction {
   async execute(context: AvmContext): Promise<void> {
     const jumpOffset = context.machineState.internalCallStack.pop();
     if (jumpOffset === undefined) {
-      throw new InstructionExecutionError('Internal call empty!');
+      throw new InstructionExecutionError('Internal call stack empty!');
     }
     context.machineState.pc = jumpOffset;
   }

package/src/avm/opcodes/external_calls.ts

@@ -1,9 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector } from '@aztec/circuits.js';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, Uint8 } from '../avm_memory_types.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 export class Call extends Instruction {
@@ -20,6 +21,8 @@ export class Call extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
+    /* temporary function selector */
+    OperandType.UINT32,
   ];
 
   constructor(
@@ -31,16 +34,30 @@ export class Call extends Instruction {
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
+    // Function selector is temporary since eventually public contract bytecode will be one blob
+    // containing all functions, and function selector will become an application-level mechanism
+    // (e.g. first few bytes of calldata + compiler-generated jump table)
+    private temporaryFunctionSelectorOffset: number,
   ) {
     super();
   }
 
   // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3992): there is no concept of remaining / available gas at this moment
   async execute(context: AvmContext): Promise<void> {
-    const callAddress = context.machineState.memory.getAs<Field>(this.addrOffset);
-    const calldata = context.machineState.memory.getSlice(this.argsOffset, this.argsSize).map(f => f.toFr());
+    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+      context.machineState.memory,
+    );
+
+    const callAddress = context.machineState.memory.getAs<Field>(addrOffset);
+    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
 
-    const nestedContext = context.createNestedContractCallContext(callAddress.toFr(), calldata);
+    const nestedContext = context.createNestedContractCallContext(
+      callAddress.toFr(),
+      calldata,
+      FunctionSelector.fromField(functionSelector),
+    );
 
     const nestedCallResults = await new AvmSimulator(nestedContext).execute();
     const success = !nestedCallResults.reverted;
@@ -50,8 +67,8 @@ export class Call extends Instruction {
     const convertedReturnData = returnData.map(f => new Field(f));
 
     // Write our return data into memory
-    context.machineState.memory.set(this.successOffset, new Field(success ? 1 : 0));
-    context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
+    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
+    context.machineState.memory.setSlice(retOffset, convertedReturnData);
 
     if (success) {
       context.persistableState.acceptNestedCallState(nestedContext.persistableState);
@@ -77,6 +94,8 @@ export class StaticCall extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
+    /* temporary function selector */
+    OperandType.UINT32,
   ];
 
   constructor(
@@ -88,17 +107,26 @@ export class StaticCall extends Instruction {
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
+    private temporaryFunctionSelectorOffset: number,
   ) {
     super();
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const callAddress = context.machineState.memory.get(this.addrOffset);
-    const calldata = context.machineState.memory
-      .getSlice(this.argsOffset, this.argsSize)
-      .map(f => new Fr(f.toBigInt()));
+    const [_gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this._gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+      context.machineState.memory,
+    );
 
-    const nestedContext = context.createNestedContractStaticCallContext(callAddress.toFr(), calldata);
+    const callAddress = context.machineState.memory.get(addrOffset);
+    const calldata = context.machineState.memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const functionSelector = context.machineState.memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+
+    const nestedContext = context.createNestedContractStaticCallContext(
+      callAddress.toFr(),
+      calldata,
+      FunctionSelector.fromField(functionSelector),
+    );
 
     const nestedCallResults = await new AvmSimulator(nestedContext).execute();
     const success = !nestedCallResults.reverted;
@@ -108,8 +136,8 @@ export class StaticCall extends Instruction {
     const convertedReturnData = returnData.map(f => new Field(f));
 
     // Write our return data into memory
-    context.machineState.memory.set(this.successOffset, new Field(success ? 1 : 0));
-    context.machineState.memory.setSlice(this.retOffset, convertedReturnData);
+    context.machineState.memory.set(successOffset, new Uint8(success ? 1 : 0));
+    context.machineState.memory.setSlice(retOffset, convertedReturnData);
 
     if (success) {
       context.persistableState.acceptNestedCallState(nestedContext.persistableState);
@@ -120,3 +148,49 @@ export class StaticCall extends Instruction {
     context.machineState.incrementPc();
   }
 }
+
+export class Return extends Instruction {
+  static type: string = 'RETURN';
+  static readonly opcode: Opcode = Opcode.RETURN;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private returnOffset: number, private copySize: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const output = context.machineState.memory.getSlice(this.returnOffset, this.copySize).map(word => word.toFr());
+
+    context.machineState.return(output);
+  }
+}
+
+export class Revert extends Instruction {
+  static type: string = 'RETURN';
+  static readonly opcode: Opcode = Opcode.REVERT;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private returnOffset: number, private retSize: number) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const output = context.machineState.memory
+      .getSlice(this.returnOffset, this.returnOffset + this.retSize)
+      .map(word => word.toFr());
+
+    context.machineState.revert(output);
+  }
+}

package/src/avm/serialization/instruction_serialization.ts

@@ -7,6 +7,7 @@ import { BufferCursor } from './buffer_cursor.js';
  * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
  */
 export enum Opcode {
+  // Compute
   ADD,
   SUB,
   MUL,
@@ -21,6 +22,7 @@ export enum Opcode {
   SHL,
   SHR,
   CAST,
+  // Execution environment
   ADDRESS,
   STORAGEADDRESS,
   ORIGIN,
@@ -39,16 +41,20 @@ export enum Opcode {
   BLOCKL2GASLIMIT,
   BLOCKDAGASLIMIT,
   CALLDATACOPY,
+  // Gas
   L1GASLEFT,
   L2GASLEFT,
   DAGASLEFT,
+  // Control flow
   JUMP,
   JUMPI,
   INTERNALCALL,
   INTERNALRETURN,
+  // Memory
   SET,
   MOV,
   CMOV,
+  // World state
   SLOAD,
   SSTORE,
   NOTEHASHEXISTS,
@@ -59,17 +65,17 @@ export enum Opcode {
   HEADERMEMBER,
   EMITUNENCRYPTEDLOG,
   SENDL2TOL1MSG,
+  // External calls
   CALL,
   STATICCALL,
   DELEGATECALL,
   RETURN,
   REVERT,
+  // Gadgets
   KECCAK,
   POSEIDON,
-  // Add new opcodes before this
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
-  TOTAL_OPCODES_NUMBER,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.

package/src/avm/temporary_executor_migration.ts

@@ -94,6 +94,7 @@ export function temporaryConvertAvmResults(
   // Disabled.
   const nestedExecutions: PublicExecutionResult[] = [];
   const nullifierReadRequests: ReadRequest[] = [];
+  const nullifierNonExistentReadRequests: ReadRequest[] = [];
   const newNullifiers: SideEffectLinkedToNoteHash[] = [];
   const unencryptedLogs = FunctionL2Logs.empty();
   const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
@@ -101,6 +102,7 @@ export function temporaryConvertAvmResults(
   return {
     execution,
     nullifierReadRequests,
+    nullifierNonExistentReadRequests,
     newNoteHashes,
     newL2ToL1Messages,
     newNullifiers,

package/src/client/client_execution_context.ts

@@ -10,7 +10,6 @@ import {
 } from '@aztec/circuit-types';
 import {
   CallContext,
-  ContractDeploymentData,
   FunctionData,
   FunctionSelector,
   Header,
@@ -89,8 +88,6 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @returns The initial witness.
    */
   public getInitialWitness(abi: FunctionAbi) {
-    const contractDeploymentData = this.txContext.contractDeploymentData;
-
     const argumentsSize = countArgumentsSize(abi);
 
     const args = this.packedArgsCache.unpack(this.argsHash);
@@ -102,7 +99,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     const fields = [
       ...this.callContext.toFields(),
       ...this.historicalHeader.toFields(),
-      ...contractDeploymentData.toFields(),
 
       this.txContext.chainId,
       this.txContext.version,
@@ -348,14 +344,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
     const targetFunctionData = FunctionData.fromAbi(targetArtifact);
 
-    const derivedTxContext = new TxContext(
-      false,
-      false,
-      false,
-      ContractDeploymentData.empty(),
-      this.txContext.chainId,
-      this.txContext.version,
-    );
+    const derivedTxContext = new TxContext(false, false, this.txContext.chainId, this.txContext.version);
 
     const derivedCallContext = await this.deriveCallContext(
       targetContractAddress,
@@ -470,7 +459,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
       isDelegateCall,
       isStaticCall,
-      false,
       startSideEffectCounter,
     );
   }

package/src/client/simulator.ts

@@ -92,10 +92,9 @@ export class AcirSimulator {
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
       false,
       false,
-      request.functionData.isConstructor,
       // TODO: when contract deployment is done in-app, we should only reserve one counter for the tx hash
       // 2 counters are reserved for tx hash and contract deployment nullifier
-      request.txContext.isContractDeploymentTx ? 2 : 1,
+      1,
     );
     const context = new ClientExecutionContext(
       contractAddress,

package/src/public/execution.ts

@@ -30,6 +30,8 @@ export interface PublicExecutionResult {
   newNullifiers: SideEffectLinkedToNoteHash[];
   /** The nullifier read requests emitted in this call. */
   nullifierReadRequests: ReadRequest[];
+  /** The nullifier non existent read requests emitted in this call. */
+  nullifierNonExistentReadRequests: ReadRequest[];
   /** The contract storage reads performed by the function. */
   contractStorageReads: ContractStorageRead[];
   /** The contract storage update requests performed by the function. */