@aztec/simulator 0.26.5 → 0.27.0

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/opcodes/storage.ts

@@ -4,6 +4,7 @@ import type { AvmContext } from '../avm_context.js';
 import { Field } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 abstract class BaseStorageInstruction extends Instruction {
@@ -13,9 +14,15 @@ abstract class BaseStorageInstruction extends Instruction {
     OperandType.UINT8,
     OperandType.UINT32,
     OperandType.UINT32,
+    OperandType.UINT32,
   ];
 
-  constructor(protected indirect: number, protected aOffset: number, protected bOffset: number) {
+  constructor(
+    protected indirect: number,
+    protected aOffset: number,
+    protected /*temporary*/ size: number,
+    protected bOffset: number,
+  ) {
     super();
   }
 }
@@ -24,8 +31,8 @@ export class SStore extends BaseStorageInstruction {
   static readonly type: string = 'SSTORE';
   static readonly opcode = Opcode.SSTORE;
 
-  constructor(indirect: number, srcOffset: number, slotOffset: number) {
-    super(indirect, srcOffset, slotOffset);
+  constructor(indirect: number, srcOffset: number, /*temporary*/ srcSize: number, slotOffset: number) {
+    super(indirect, srcOffset, srcSize, slotOffset);
   }
 
   async execute(context: AvmContext): Promise<void> {
@@ -33,15 +40,19 @@ export class SStore extends BaseStorageInstruction {
       throw new StaticCallStorageAlterError();
     }
 
-    const slot = context.machineState.memory.get(this.aOffset);
-    const data = context.machineState.memory.get(this.bOffset);
-
-    context.persistableState.writeStorage(
-      context.environment.storageAddress,
-      new Fr(slot.toBigInt()),
-      new Fr(data.toBigInt()),
+    const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset],
+      context.machineState.memory,
     );
 
+    const slot = context.machineState.memory.get(slotOffset).toFr();
+    const data = context.machineState.memory.getSlice(srcOffset, this.size).map(field => field.toFr());
+
+    for (const [index, value] of Object.entries(data)) {
+      const adjustedSlot = slot.add(new Fr(BigInt(index)));
+      context.persistableState.writeStorage(context.environment.storageAddress, adjustedSlot, value);
+    }
+
     context.machineState.incrementPc();
   }
 }
@@ -50,19 +61,27 @@ export class SLoad extends BaseStorageInstruction {
   static readonly type: string = 'SLOAD';
   static readonly opcode = Opcode.SLOAD;
 
-  constructor(indirect: number, slotOffset: number, dstOffset: number) {
-    super(indirect, slotOffset, dstOffset);
+  constructor(indirect: number, slotOffset: number, size: number, dstOffset: number) {
+    super(indirect, slotOffset, size, dstOffset);
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const slot = context.machineState.memory.get(this.aOffset);
-
-    const data: Fr = await context.persistableState.readStorage(
-      context.environment.storageAddress,
-      new Fr(slot.toBigInt()),
+    const [aOffset, size, bOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.size, this.bOffset],
+      context.machineState.memory,
     );
 
-    context.machineState.memory.set(this.bOffset, new Field(data));
+    const slot = context.machineState.memory.get(aOffset);
+
+    // Write each read value from storage into memory
+    for (let i = 0; i < size; i++) {
+      const data: Fr = await context.persistableState.readStorage(
+        context.environment.storageAddress,
+        new Fr(slot.toBigInt() + BigInt(i)),
+      );
+
+      context.machineState.memory.set(bOffset + i, new Field(data));
+    }
 
     context.machineState.incrementPc();
   }

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

@@ -5,11 +5,13 @@ import {
   ContractStorageUpdateRequest,
   GlobalVariables,
   L2ToL1Message,
+  ReadRequest,
   SideEffect,
   SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
+import { createSimulationError } from '../common/errors.js';
 import { PublicExecution, PublicExecutionResult } from '../public/execution.js';
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
@@ -91,12 +93,14 @@ export function temporaryConvertAvmResults(
   // TODO(follow up in pr tree): NOT SUPPORTED YET, make sure hashing and log resolution is done correctly
   // Disabled.
   const nestedExecutions: PublicExecutionResult[] = [];
+  const nullifierReadRequests: ReadRequest[] = [];
   const newNullifiers: SideEffectLinkedToNoteHash[] = [];
   const unencryptedLogs = FunctionL2Logs.empty();
   const newL2ToL1Messages = newWorldState.newL1Messages.map(() => L2ToL1Message.empty());
 
   return {
     execution,
+    nullifierReadRequests,
     newNoteHashes,
     newL2ToL1Messages,
     newNullifiers,
@@ -105,5 +109,7 @@ export function temporaryConvertAvmResults(
     returnValues,
     nestedExecutions,
     unencryptedLogs,
+    reverted: result.reverted,
+    revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
   };
 }

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/index.ts

@@ -1,3 +1,4 @@
-export * from './client/index.js';
 export * from './acvm/index.js';
+export * from './client/index.js';
+export * from './common/index.js';
 export * from './public/index.js';

package/src/public/execution.ts

@@ -1,14 +1,14 @@
-import { FunctionL2Logs } from '@aztec/circuit-types';
+import { FunctionL2Logs, SimulationError } from '@aztec/circuit-types';
 import {
   AztecAddress,
-  CallContext,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
-  FunctionData,
   L2ToL1Message,
+  PublicCallRequest,
   PublicDataRead,
   PublicDataUpdateRequest,
+  ReadRequest,
   SideEffect,
   SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
@@ -28,6 +28,8 @@ export interface PublicExecutionResult {
   newL2ToL1Messages: L2ToL1Message[];
   /** The new nullifiers to be inserted into the nullifier tree. */
   newNullifiers: SideEffectLinkedToNoteHash[];
+  /** The nullifier read requests emitted in this call. */
+  nullifierReadRequests: ReadRequest[];
   /** The contract storage reads performed by the function. */
   contractStorageReads: ContractStorageRead[];
   /** The contract storage update requests performed by the function. */
@@ -39,21 +41,20 @@ export interface PublicExecutionResult {
    * Note: These are preimages to `unencryptedLogsHash`.
    */
   unencryptedLogs: FunctionL2Logs;
+  /**
+   * Whether the execution reverted.
+   */
+  reverted: boolean;
+  /**
+   * The revert reason if the execution reverted.
+   */
+  revertReason: SimulationError | undefined;
 }
 
 /**
  * The execution of a public function.
  */
-export interface PublicExecution {
-  /** Address of the contract being executed. */
-  contractAddress: AztecAddress;
-  /** Function of the contract being called. */
-  functionData: FunctionData;
-  /** Arguments for the call. */
-  args: Fr[];
-  /** Context of the call. */
-  callContext: CallContext;
-}
+export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'functionData' | 'callContext' | 'args'>;
 
 /**
  * Returns if the input is a public execution result and not just a public execution.
@@ -63,7 +64,7 @@ export interface PublicExecution {
 export function isPublicExecutionResult(
   input: PublicExecution | PublicExecutionResult,
 ): input is PublicExecutionResult {
-  return !!(input as PublicExecutionResult).execution;
+  return 'execution' in input && input.execution !== undefined;
 }
 
 /**