@aztec/simulator 0.26.6 → 0.27.0

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

@@ -2,6 +2,10 @@ import { FunctionL2Logs } from '@aztec/circuit-types';
 import { GlobalVariables, Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+
 import { Oracle, acvm, extractCallStack, extractReturnWitness } from '../acvm/index.js';
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
@@ -220,4 +224,99 @@ export class PublicExecutor {
     const newWorldState = context.persistableState.flush();
     return temporaryConvertAvmResults(execution, newWorldState, result);
   }
+
+  /**
+   * These functions are currently housed in the temporary executor as it relies on access to
+   * oracles like the contractsDB and this is the least intrusive way to achieve this.
+   * When we remove this executor(tracking issue #4792) and have an interface that is compatible with the kernel circuits,
+   * this will be moved to sequencer-client/prover.
+   */
+
+  /**
+   * Generates a proof for an associated avm execution. This is currently only used for testing purposes,
+   * as proof generation is not fully complete in the AVM yet.
+   * @param execution - The execution to run.
+   * @returns An AVM proof and the verification key.
+   */
+  public async getAvmProof(avmExecution: PublicExecution): Promise<Buffer[]> {
+    // The paths for the barretenberg binary and the write path are hardcoded for now.
+    // We additionally need the path to a valid crs for proof generation.
+    // const bbPath = '../../barretenberg/cpp';
+    const bbPath = path.resolve('../../barretenberg/cpp');
+    const artifactsPath = path.resolve('target');
+
+    // Create the directory if it does not exist
+    await fs.mkdir(artifactsPath, { recursive: true });
+
+    const calldataPath = path.join(artifactsPath, 'calldata.bin');
+    const bytecodePath = path.join(artifactsPath, 'avm_bytecode.bin');
+    const proofPath = path.join(artifactsPath, 'proof');
+
+    const { args, functionData, contractAddress } = avmExecution;
+    const bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
+    // Write call data and bytecode to files.
+    await Promise.all([
+      fs.writeFile(
+        calldataPath,
+        args.map(c => c.toBuffer()),
+      ),
+      fs.writeFile(bytecodePath, bytecode!),
+    ]);
+
+    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), [
+      'avm_prove',
+      '-b',
+      bytecodePath,
+      '-d',
+      calldataPath,
+      '-c',
+      path.join(bbPath, 'srs_db', 'ignition'),
+      '-o',
+      proofPath,
+    ]);
+    // The binary writes the proof and the verification key to the write path.
+    return new Promise((resolve, reject) => {
+      bbBinary.on('close', () => {
+        resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
+      });
+      // Catch and propagate errors from spawning
+      bbBinary.on('error', err => {
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Verifies an AVM proof. This function is currently only used for testing purposes, as verification
+   * is not fully complete in the AVM yet.
+   * @param vk - The verification key to use.
+   * @param proof - The proof to verify.
+   * @returns True if the proof is valid, false otherwise.
+   */
+  async verifyAvmProof(vk: Buffer, proof: Buffer): Promise<boolean> {
+    // The relative paths for the barretenberg binary and the write path are hardcoded for now.
+    const bbPath = path.resolve('../../barretenberg/cpp');
+    const artifactsPath = path.resolve('./target');
+
+    const vkPath = path.join(artifactsPath, 'vk');
+    const proofPath = path.join(artifactsPath, 'proof');
+
+    // Write the verification key and the proof to files.
+    await Promise.all([fs.writeFile(vkPath, vk), fs.writeFile(proofPath, proof)]);
+
+    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), ['avm_verify', '-p', proofPath]);
+    // The binary prints to stdout 1 if the proof is valid and 0 if it is not.
+    return new Promise((resolve, reject) => {
+      let result = Buffer.alloc(0);
+      bbBinary.stdout.on('data', data => {
+        result += data;
+      });
+      bbBinary.on('close', () => {
+        resolve(result.toString() === '1');
+      });
+      // Catch and propagate errors from spawning
+      bbBinary.on('error', err => {
+        reject(err);
+      });
+    });
+  }
 }

package/src/public/public_execution_context.ts

@@ -186,7 +186,6 @@ export class PublicExecutionContext extends TypedOracle {
       storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
       portalContractAddress: portalAddress,
       functionSelector,
-      isContractDeployment: false,
       isDelegateCall,
       isStaticCall,
       startSideEffectCounter: 0, // TODO use counters in public execution