@aztec/simulator 0.30.1 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -30,11 +30,12 @@
     "rootDir": "./src"
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.30.1",
-    "@aztec/circuits.js": "0.30.1",
-    "@aztec/foundation": "0.30.1",
-    "@aztec/types": "0.30.1",
+    "@aztec/circuit-types": "0.31.0",
+    "@aztec/circuits.js": "0.31.0",
+    "@aztec/foundation": "0.31.0",
+    "@aztec/types": "0.31.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
+    "@noir-lang/types": "portal:../../noir/packages/types",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",
     "tslib": "^2.4.0"

package/src/acvm/oracle/oracle.ts

@@ -244,8 +244,16 @@ export class Oracle {
     return toACVMField(exists);
   }
 
-  async getL1ToL2MembershipWitness([entryKey]: ACVMField[]): Promise<ACVMField[]> {
-    const message = await this.typedOracle.getL1ToL2MembershipWitness(fromACVMField(entryKey));
+  async getL1ToL2MembershipWitness(
+    [contractAddress]: ACVMField[],
+    [messageHash]: ACVMField[],
+    [secret]: ACVMField[],
+  ): Promise<ACVMField[]> {
+    const message = await this.typedOracle.getL1ToL2MembershipWitness(
+      AztecAddress.fromString(contractAddress),
+      fromACVMField(messageHash),
+      fromACVMField(secret),
+    );
     return message.toFields().map(toACVMField);
   }
 

package/src/acvm/oracle/typed_oracle.ts

@@ -171,7 +171,11 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('checkNullifierExists');
   }
 
-  getL1ToL2MembershipWitness(_entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+  getL1ToL2MembershipWitness(
+    _contractAddress: AztecAddress,
+    _messageHash: Fr,
+    _secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
     throw new OracleMethodNotAvailableError('getL1ToL2MembershipWitness');
   }
 

package/src/avm/avm_execution_environment.ts

@@ -1,8 +1,19 @@
 import { FunctionSelector, GlobalVariables } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { pedersenHash } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 
+export class AvmContextInputs {
+  static readonly SIZE = 2;
+
+  constructor(private selector: Fr, private argsHash: Fr) {}
+
+  public toFields(): Fr[] {
+    return [this.selector, this.argsHash];
+  }
+}
+
 /**
  * Contains variables that remain constant during AVM execution
  * These variables are provided by the public kernel circuit
@@ -40,7 +51,15 @@ export class AvmExecutionEnvironment {
     // 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,
-  ) {}
+  ) {
+    // We encode some extra inputs (AvmContextInputs) in calldata.
+    // This will have to go once we move away from one proof per call.
+    const inputs = new AvmContextInputs(
+      temporaryFunctionSelector.toField(),
+      pedersenHash(calldata.map(word => word.toBuffer())),
+    );
+    this.calldata = [...inputs.toFields(), ...calldata];
+  }
 
   public deriveEnvironmentForNestedCall(
     address: AztecAddress,

package/src/avm/avm_gas_cost.ts

@@ -0,0 +1,94 @@
+import { Opcode } from './serialization/instruction_serialization.js';
+
+/** Gas cost in L1, L2, and DA for a given instruction. */
+export type GasCost = {
+  l1Gas: number;
+  l2Gas: number;
+  daGas: number;
+};
+
+/** Gas cost of zero across all gas dimensions. */
+export const EmptyGasCost = {
+  l1Gas: 0,
+  l2Gas: 0,
+  daGas: 0,
+};
+
+/** Dimensions of gas usage: L1, L2, and DA */
+export const GasDimensions = ['l1Gas', 'l2Gas', 'daGas'] as const;
+
+/** Temporary default gas cost. We should eventually remove all usage of this variable in favor of actual gas for each opcode. */
+const TemporaryDefaultGasCost = { l1Gas: 0, l2Gas: 10, daGas: 0 };
+
+/** Gas costs for each instruction. */
+export const GasCosts: Record<Opcode, GasCost> = {
+  [Opcode.ADD]: TemporaryDefaultGasCost,
+  [Opcode.SUB]: TemporaryDefaultGasCost,
+  [Opcode.MUL]: TemporaryDefaultGasCost,
+  [Opcode.DIV]: TemporaryDefaultGasCost,
+  [Opcode.FDIV]: TemporaryDefaultGasCost,
+  [Opcode.EQ]: TemporaryDefaultGasCost,
+  [Opcode.LT]: TemporaryDefaultGasCost,
+  [Opcode.LTE]: TemporaryDefaultGasCost,
+  [Opcode.AND]: TemporaryDefaultGasCost,
+  [Opcode.OR]: TemporaryDefaultGasCost,
+  [Opcode.XOR]: TemporaryDefaultGasCost,
+  [Opcode.NOT]: TemporaryDefaultGasCost,
+  [Opcode.SHL]: TemporaryDefaultGasCost,
+  [Opcode.SHR]: TemporaryDefaultGasCost,
+  [Opcode.CAST]: TemporaryDefaultGasCost,
+  // Execution environment
+  [Opcode.ADDRESS]: TemporaryDefaultGasCost,
+  [Opcode.STORAGEADDRESS]: TemporaryDefaultGasCost,
+  [Opcode.ORIGIN]: TemporaryDefaultGasCost,
+  [Opcode.SENDER]: TemporaryDefaultGasCost,
+  [Opcode.PORTAL]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERL1GAS]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERL2GAS]: TemporaryDefaultGasCost,
+  [Opcode.FEEPERDAGAS]: TemporaryDefaultGasCost,
+  [Opcode.CONTRACTCALLDEPTH]: TemporaryDefaultGasCost,
+  [Opcode.CHAINID]: TemporaryDefaultGasCost,
+  [Opcode.VERSION]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKNUMBER]: TemporaryDefaultGasCost,
+  [Opcode.TIMESTAMP]: TemporaryDefaultGasCost,
+  [Opcode.COINBASE]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKL1GASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKL2GASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.BLOCKDAGASLIMIT]: TemporaryDefaultGasCost,
+  [Opcode.CALLDATACOPY]: TemporaryDefaultGasCost,
+  // Gas
+  [Opcode.L1GASLEFT]: TemporaryDefaultGasCost,
+  [Opcode.L2GASLEFT]: TemporaryDefaultGasCost,
+  [Opcode.DAGASLEFT]: TemporaryDefaultGasCost,
+  // Control flow
+  [Opcode.JUMP]: TemporaryDefaultGasCost,
+  [Opcode.JUMPI]: TemporaryDefaultGasCost,
+  [Opcode.INTERNALCALL]: TemporaryDefaultGasCost,
+  [Opcode.INTERNALRETURN]: TemporaryDefaultGasCost,
+  // Memory
+  [Opcode.SET]: TemporaryDefaultGasCost,
+  [Opcode.MOV]: TemporaryDefaultGasCost,
+  [Opcode.CMOV]: TemporaryDefaultGasCost,
+  // World state
+  [Opcode.SLOAD]: TemporaryDefaultGasCost,
+  [Opcode.SSTORE]: TemporaryDefaultGasCost,
+  [Opcode.NOTEHASHEXISTS]: TemporaryDefaultGasCost,
+  [Opcode.EMITNOTEHASH]: TemporaryDefaultGasCost,
+  [Opcode.NULLIFIEREXISTS]: TemporaryDefaultGasCost,
+  [Opcode.EMITNULLIFIER]: TemporaryDefaultGasCost,
+  [Opcode.L1TOL2MSGEXISTS]: TemporaryDefaultGasCost,
+  [Opcode.HEADERMEMBER]: TemporaryDefaultGasCost,
+  [Opcode.EMITUNENCRYPTEDLOG]: TemporaryDefaultGasCost,
+  [Opcode.SENDL2TOL1MSG]: TemporaryDefaultGasCost,
+  // External calls
+  [Opcode.CALL]: TemporaryDefaultGasCost,
+  [Opcode.STATICCALL]: TemporaryDefaultGasCost,
+  [Opcode.DELEGATECALL]: TemporaryDefaultGasCost,
+  [Opcode.RETURN]: TemporaryDefaultGasCost,
+  [Opcode.REVERT]: TemporaryDefaultGasCost,
+  // Gadgets
+  [Opcode.KECCAK]: TemporaryDefaultGasCost,
+  [Opcode.POSEIDON]: TemporaryDefaultGasCost,
+  [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
+  [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
+};

package/src/avm/avm_machine_state.ts

@@ -1,7 +1,9 @@
 import { Fr } from '@aztec/circuits.js';
 
+import { GasCost, GasDimensions } from './avm_gas_cost.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { AvmContractCallResults } from './avm_message_call_result.js';
+import { OutOfGasError } from './errors.js';
 
 /**
  * A few fields of machine state are initialized from AVM session inputs or call instruction arguments
@@ -35,7 +37,7 @@ export class AvmMachineState {
   /**
    * Signals that execution should end.
    * AvmContext execution continues executing instructions until the machine state signals "halted"
-   * */
+   */
   public halted: boolean = false;
   /** Signals that execution has reverted normally (this does not cover exceptional halts) */
   private reverted: boolean = false;
@@ -52,6 +54,28 @@ export class AvmMachineState {
     return new AvmMachineState(state.l1GasLeft, state.l2GasLeft, state.daGasLeft);
   }
 
+  /**
+   * Consumes the given gas.
+   * Should any of the gas dimensions get depleted, it sets all gas left to zero and triggers
+   * an exceptional halt by throwing an OutOfGasError.
+   */
+  public consumeGas(gasCost: Partial<GasCost>) {
+    // Assert there is enough gas on every dimension.
+    const outOfGasDimensions = GasDimensions.filter(
+      dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
+    );
+    // If not, trigger an exceptional halt.
+    // See https://yp-aztec.netlify.app/docs/public-vm/execution#gas-checks-and-tracking
+    if (outOfGasDimensions.length > 0) {
+      this.exceptionalHalt();
+      throw new OutOfGasError(outOfGasDimensions);
+    }
+    // Otherwise, charge the corresponding gas
+    for (const dimension of GasDimensions) {
+      this[`${dimension}Left`] -= gasCost[dimension] ?? 0;
+    }
+  }
+
   /**
    * Most instructions just increment PC before they complete
    */
@@ -80,6 +104,15 @@ export class AvmMachineState {
     this.output = output;
   }
 
+  /**
+   * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
+   */
+  protected exceptionalHalt() {
+    GasDimensions.forEach(dimension => (this[`${dimension}Left`] = 0));
+    this.reverted = true;
+    this.halted = true;
+  }
+
   /**
    * Get a summary of execution results for a halted machine state
    * @returns summary of execution results

package/src/avm/avm_memory_types.ts

@@ -229,6 +229,7 @@ export class TaggedMemory {
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
     TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
   }
 

package/src/avm/avm_simulator.ts

@@ -50,7 +50,6 @@ export class AvmSimulator {
    */
   public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
     assert(instructions.length > 0);
-
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
@@ -65,7 +64,7 @@ export class AvmSimulator {
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        await instruction.execute(this.context);
+        await instruction.run(this.context);
 
         if (this.context.machineState.pc >= instructions.length) {
           this.log('Passed end of program!');

package/src/avm/errors.ts

@@ -55,3 +55,11 @@ export class TagCheckError extends AvmExecutionError {
     this.name = 'TagCheckError';
   }
 }
+
+/** Error thrown when out of gas. */
+export class OutOfGasError extends AvmExecutionError {
+  constructor(dimensions: string[]) {
+    super(`Not enough ${dimensions.map(d => d.toUpperCase()).join(', ')} gas left`);
+    this.name = 'OutOfGasError';
+  }
+}

package/src/avm/fixtures/index.ts

@@ -10,7 +10,7 @@ import merge from 'lodash.merge';
 
 import { CommitmentsDB, MessageLoadOracleInputs, PublicContractsDB, PublicStateDB } from '../../index.js';
 import { AvmContext } from '../avm_context.js';
-import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmContextInputs, AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
 import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
@@ -85,13 +85,13 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
 }
 
 /**
- * Create an empty instance of the Machine State where all values are zero, unless overridden in the overrides object
+ * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
  */
 export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
   return AvmMachineState.fromState({
-    l1GasLeft: overrides?.l1GasLeft ?? 0,
-    l2GasLeft: overrides?.l2GasLeft ?? 0,
-    daGasLeft: overrides?.daGasLeft ?? 0,
+    l1GasLeft: overrides?.l1GasLeft ?? 1e6,
+    l2GasLeft: overrides?.l2GasLeft ?? 1e6,
+    daGasLeft: overrides?.daGasLeft ?? 1e6,
   });
 }
 
@@ -113,3 +113,19 @@ export function initL1ToL2MessageOracleInput(
     new SiblingPath(L1_TO_L2_MSG_TREE_HEIGHT, Array(L1_TO_L2_MSG_TREE_HEIGHT)),
   );
 }
+
+/**
+ * Adjust the user index to account for the AvmContextInputs size.
+ * This is a hack for testing, and should go away once AvmContextInputs themselves go away.
+ */
+export function adjustCalldataIndex(userIndex: number): number {
+  return userIndex + AvmContextInputs.SIZE;
+}
+
+export function anyAvmContextInputs() {
+  const tv = [];
+  for (let i = 0; i < AvmContextInputs.SIZE; i++) {
+    tv.push(expect.any(Fr));
+  }
+  return tv;
+}

package/src/avm/journal/journal.ts

@@ -156,7 +156,16 @@ export class AvmPersistableStateManager {
   public async checkL1ToL2MessageExists(msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
     let exists = false;
     try {
-      const gotMessage = await this.hostStorage.commitmentsDb.getL1ToL2MembershipWitness(msgHash);
+      // The following 2 values are used to compute a message nullifier. Given that here we do not care about getting
+      // non-nullified messages we can just pass in random values and the nullifier check will effectively be ignored
+      // (no nullifier will be found).
+      const ignoredContractAddress = AztecAddress.random();
+      const ignoredSecret = Fr.random();
+      const gotMessage = await this.hostStorage.commitmentsDb.getL1ToL2MembershipWitness(
+        ignoredContractAddress,
+        msgHash,
+        ignoredSecret,
+      );
       exists = gotMessage !== undefined && gotMessage.index == msgLeafIndex.toBigInt();
     } catch {
       // error getting message - doesn't exist!

package/src/avm/opcodes/hashing.ts

@@ -23,21 +23,24 @@ export class Poseidon2 extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
 
   async execute(context: AvmContext): Promise<void> {
     // We hash a set of field elements
-    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
+      context.machineState.memory,
+    );
 
     // Memory pointer will be indirect
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = poseidonHash(hashData);
-    context.machineState.memory.set(this.dstOffset, new Field(hash));
+    context.machineState.memory.set(dstOffset, new Field(hash));
 
     context.machineState.incrementPc();
   }
@@ -59,8 +62,8 @@ export class Keccak extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
@@ -68,12 +71,12 @@ export class Keccak extends Instruction {
   // Note hash output is 32 bytes, so takes up two fields
   async execute(context: AvmContext): Promise<void> {
     // We hash a set of field elements
-    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.hashOffset, this.dstOffset],
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
       context.machineState.memory,
     );
 
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = keccak(Buffer.concat(hashData));
 
@@ -104,21 +107,21 @@ export class Sha256 extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSize: number,
   ) {
     super();
   }
 
   // Note hash output is 32 bytes, so takes up two fields
   async execute(context: AvmContext): Promise<void> {
-    const [hashOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.hashOffset, this.dstOffset],
+    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset],
       context.machineState.memory,
     );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const hashData = context.machineState.memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
 
     const hash = sha256(Buffer.concat(hashData));
 
@@ -149,21 +152,25 @@ export class Pedersen extends Instruction {
   constructor(
     private indirect: number,
     private dstOffset: number,
-    private hashOffset: number,
-    private hashSize: number,
+    private messageOffset: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
   async execute(context: AvmContext): Promise<void> {
-    const [hashOffset] = Addressing.fromWire(this.indirect).resolve([this.hashOffset], context.machineState.memory);
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
+      context.machineState.memory,
+    );
 
     // We hash a set of field elements
-    const hashData = context.machineState.memory.getSlice(hashOffset, this.hashSize).map(word => word.toBuffer());
+    const messageSize = Number(context.machineState.memory.get(messageSizeOffset).toBigInt());
+    const hashData = context.machineState.memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer());
 
     // No domain sep for now
     const hash = pedersenHash(hashData);
-    context.machineState.memory.set(this.dstOffset, new Field(hash));
+    context.machineState.memory.set(dstOffset, new Field(hash));
 
     context.machineState.incrementPc();
   }

package/src/avm/opcodes/instruction.ts

@@ -1,8 +1,9 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
+import { EmptyGasCost, GasCost, GasCosts } from '../avm_gas_cost.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
-import { OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
+import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {
   new (...args: any[]): Instruction;
@@ -14,6 +15,24 @@ type InstructionConstructor = {
  * It's most important aspects are execute and (de)serialize.
  */
 export abstract class Instruction {
+  /**
+   * Consumes gas and executes the instruction.
+   * This is the main entry point for the instruction.
+   * @param context - The AvmContext in which the instruction executes.
+   */
+  public run(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+    return this.execute(context);
+  }
+
+  /**
+   * Loads default gas cost for the instruction from the GasCosts table.
+   * Instruction sub-classes can override this if their gas cost is not fixed.
+   */
+  public gasCost(): GasCost {
+    return GasCosts[this.opcode] ?? EmptyGasCost;
+  }
+
   /**
    * Execute the instruction.
    * Instruction sub-classes must implement this.
@@ -21,7 +40,7 @@ export abstract class Instruction {
    * each instruction until the machine state signals "halted".
    * @param context - The AvmContext in which the instruction executes.
    */
-  public abstract execute(context: AvmContext): Promise<void>;
+  protected abstract execute(context: AvmContext): Promise<void>;
 
   /**
    * Generate a string representation of the instruction including
@@ -61,4 +80,28 @@ export abstract class Instruction {
     const args = res.slice(1); // Remove opcode.
     return new this(...args);
   }
+
+  /**
+   * Returns the stringified type of the instruction.
+   * Instruction sub-classes should have a static `type` property.
+   */
+  public get type(): string {
+    const type = 'type' in this.constructor && (this.constructor.type as string);
+    if (!type) {
+      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
+    }
+    return type;
+  }
+
+  /**
+   * Returns the opcode of the instruction.
+   * Instruction sub-classes should have a static `opcode` property.
+   */
+  public get opcode(): Opcode {
+    const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
+    if (opcode === undefined || Opcode[opcode] === undefined) {
+      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
+    }
+    return opcode;
+  }
 }

package/src/client/private_execution.ts

@@ -3,7 +3,6 @@ import { FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/fo
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { to2Fields } from '@aztec/foundation/serialize';
 
 import { extractReturnWitness } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
@@ -24,7 +23,7 @@ export async function executePrivateFunction(
 ): Promise<ExecutionResult> {
   const functionSelector = functionData.selector;
   log(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
-  const acir = Buffer.from(artifact.bytecode, 'base64');
+  const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
   const { partialWitness } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
@@ -47,9 +46,9 @@ export async function executePrivateFunction(
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
   // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-  publicInputs.encryptedLogsHash = to2Fields(encryptedLogs.hash());
+  publicInputs.encryptedLogsHash = Fr.fromBuffer(encryptedLogs.hash());
   publicInputs.encryptedLogPreimagesLength = new Fr(encryptedLogs.getSerializedLength());
-  publicInputs.unencryptedLogsHash = to2Fields(unencryptedLogs.hash());
+  publicInputs.unencryptedLogsHash = Fr.fromBuffer(unencryptedLogs.hash());
   publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);

package/src/client/unconstrained_execution.ts

@@ -25,7 +25,7 @@ export async function executeUnconstrainedFunction(
   const functionSelector = functionData.selector;
   log(`Executing unconstrained function ${contractAddress}:${functionSelector}`);
 
-  const acir = Buffer.from(artifact.bytecode, 'base64');
+  const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
   const { partialWitness } = await acvm(
     await AcirSimulator.getSolver(),

package/src/client/view_data_oracle.ts

@@ -225,12 +225,15 @@ export class ViewDataOracle extends TypedOracle {
   }
 
   /**
-   * Fetches the a message from the db, given its key.
-   * @param entryKey - A buffer representing the entry key.
-   * @returns The l1 to l2 message data
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
-  public async getL1ToL2MembershipWitness(entryKey: Fr) {
-    return await this.db.getL1ToL2MembershipWitness(entryKey);
+  public async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
+    return await this.db.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
   }
 
   /**

package/src/index.ts

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

package/src/public/db.ts

@@ -79,12 +79,18 @@ export interface PublicContractsDB {
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */
 export interface CommitmentsDB {
   /**
-   * Gets a confirmed L1 to L2 message for the given entry key.
-   * TODO(Maddiaa): Can be combined with aztec-node method that does the same thing.
-   * @param entryKey - The entry key.
-   * @returns - The l1 to l2 message object
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
-  getL1ToL2MembershipWitness(entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+  getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
 
   /**
    * Gets the index of a commitment in the note hash tree.

package/src/public/executor.ts

@@ -229,13 +229,15 @@ export class PublicExecutor {
     const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
     const worldStateJournal = new AvmPersistableStateManager(hostStorage);
     const executionEnv = temporaryCreateAvmExecutionEnvironment(execution, globalVariables);
-    const machineState = new AvmMachineState(0, 0, 0);
+    // TODO(@spalladino) Load initial gas from the public execution request
+    const machineState = new AvmMachineState(100_000, 100_000, 100_000);
 
     const context = new AvmContext(worldStateJournal, executionEnv, machineState);
     const simulator = new AvmSimulator(context);
 
     const result = await simulator.execute();
     const newWorldState = context.persistableState.flush();
+    // TODO(@spalladino) Read gas left from machineState and return it
     return temporaryConvertAvmResults(execution, newWorldState, result);
   }