@aztec/simulator 0.34.0 → 0.35.1

package/src/avm/opcodes/accrued_substate.ts

@@ -80,19 +80,31 @@ export class NullifierExists extends Instruction {
   static type: string = 'NULLIFIEREXISTS';
   static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
 
-  constructor(private indirect: number, private nullifierOffset: number, private existsOffset: number) {
+  constructor(
+    private indirect: number,
+    private nullifierOffset: number,
+    private addressOffset: number,
+    private existsOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     const nullifier = memory.get(this.nullifierOffset).toFr();
-    const exists = await context.persistableState.checkNullifierExists(context.environment.storageAddress, nullifier);
+    const address = memory.get(this.addressOffset).toFr();
+    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
     memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 

package/src/avm/opcodes/context_getters.ts

@@ -7,7 +7,7 @@ export class L2GasLeft extends GetterInstruction {
   static type: string = 'L2GASLEFT';
   static readonly opcode: Opcode = Opcode.L2GASLEFT;
 
-  // TODO(@spalladino) Yellow paper specifies that the value should be an Uint32, not a Field.
+  // TODO(@spalladino) Protocol specs specifies that the value should be an Uint32, not a Field.
   protected getValue(context: AvmContext): MemoryValue {
     return new Field(context.machineState.l2GasLeft);
   }

package/src/avm/opcodes/external_calls.ts

@@ -36,7 +36,7 @@ abstract class ExternalCall extends Instruction {
     private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
     private addrOffset: number,
     private argsOffset: number,
-    private argsSize: number,
+    private argsSizeOffset: number,
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
@@ -50,20 +50,23 @@ abstract class ExternalCall extends Instruction {
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory.track(this.type);
-    const [gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset] = Addressing.fromWire(
+      this.indirect,
+    ).resolve(
+      [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.retOffset, this.successOffset],
       memory,
     );
 
     const callAddress = memory.getAs<Field>(addrOffset);
-    const calldata = memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const calldataSize = memory.get(argsSizeOffset).toNumber();
+    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
     const l1Gas = memory.get(gasOffset).toNumber();
     const l2Gas = memory.getAs<Field>(gasOffset + 1).toNumber();
     const daGas = memory.getAs<Field>(gasOffset + 2).toNumber();
     const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
 
     const allocatedGas = { l1Gas, l2Gas, daGas };
-    const memoryOperations = { reads: this.argsSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
+    const memoryOperations = { reads: calldataSize + 6, writes: 1 + this.retSize, indirect: this.indirect };
     const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
     context.machineState.consumeGas(totalGas);
 

package/src/avm/opcodes/hashing.ts

@@ -1,15 +1,15 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { keccak, pedersenHash, poseidonHash, sha256 } from '@aztec/foundation/crypto';
+import { keccak256, pedersenHash, poseidon2Permutation, sha256 } from '@aztec/foundation/crypto';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, Uint8 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 export class Poseidon2 extends Instruction {
   static type: string = 'POSEIDON2';
-  static readonly opcode: Opcode = Opcode.POSEIDON;
+  static readonly opcode: Opcode = Opcode.POSEIDON2;
+  static readonly stateSize = 4;
 
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
@@ -17,34 +17,28 @@ export class Poseidon2 extends Instruction {
     OperandType.UINT8,
     OperandType.UINT32,
     OperandType.UINT32,
-    OperandType.UINT32,
   ];
 
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSize: number,
-  ) {
+  constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 1, indirect: this.indirect };
+    const memoryOperations = { reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // We hash a set of field elements
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [inputOffset, outputOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.inputStateOffset, this.outputStateOffset],
       memory,
     );
 
-    // Memory pointer will be indirect
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = poseidonHash(hashData);
-    memory.set(dstOffset, new Field(hash));
+    const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
+    const outputState = poseidon2Permutation(inputState);
+    memory.setSlice(
+      outputOffset,
+      outputState.map(word => new Field(word)),
+    );
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -68,33 +62,28 @@ export class Keccak extends Instruction {
     private indirect: number,
     private dstOffset: number,
     private messageOffset: number,
-    private messageSize: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
-  // Note hash output is 32 bytes, so takes up two fields
+  // pub fn keccak256(input: [u8], message_size: u32) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
-
-    // We hash a set of field elements
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
       memory,
     );
+    const messageSize = memory.get(messageSizeOffset).toNumber();
+    const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = keccak(Buffer.concat(hashData));
-
-    // Split output into two fields
-    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
-    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
+    const hashBuffer = keccak256(messageData);
 
-    memory.set(dstOffset, high);
-    memory.set(dstOffset + 1, low);
+    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
+    const res = [...hashBuffer].map(byte => new Uint8(byte));
+    memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -118,33 +107,28 @@ export class Sha256 extends Instruction {
     private indirect: number,
     private dstOffset: number,
     private messageOffset: number,
-    private messageSize: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
-  // Note hash output is 32 bytes, so takes up two fields
+  // pub fn sha256_slice(input: [u8]) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
-
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
       memory,
     );
+    const messageSize = memory.get(messageSizeOffset).toNumber();
+    const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // We hash a set of field elements
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = sha256(Buffer.concat(hashData));
-
-    // Split output into two fields
-    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
-    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
+    const hashBuffer = sha256(messageData);
 
-    memory.set(dstOffset, high);
-    memory.set(dstOffset + 1, low);
+    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
+    const res = [...hashBuffer].map(byte => new Uint8(byte));
+    memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/serialization/instruction_serialization.ts

@@ -75,7 +75,7 @@ export enum Opcode {
   REVERT,
   // Gadgets
   KECCAK,
-  POSEIDON,
+  POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
 }

package/src/client/client_execution_context.ts

@@ -28,7 +28,7 @@ import { Fr, type Point } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { type NoteData, toACVMWitness } from '../acvm/index.js';
-import { type PackedArgsCache } from '../common/packed_args_cache.js';
+import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
 import { type ExecutionResult, type NoteAndSlot } from './execution_result.js';
@@ -72,7 +72,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     protected readonly historicalHeader: Header,
     /** List of transient auth witnesses to be used during this simulation */
     protected readonly authWitnesses: AuthWitness[],
-    private readonly packedArgsCache: PackedArgsCache,
+    private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
     protected readonly db: DBOracle,
     private readonly curve: Grumpkin,
@@ -93,7 +93,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public getInitialWitness(abi: FunctionAbi) {
     const argumentsSize = countArgumentsSize(abi);
 
-    const args = this.packedArgsCache.unpack(this.argsHash);
+    const args = this.packedValuesCache.unpack(this.argsHash);
 
     if (args.length !== argumentsSize) {
       throw new Error('Invalid arguments size');
@@ -175,7 +175,23 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param args - Arguments to pack
    */
   public packArguments(args: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.packedArgsCache.pack(args));
+    return Promise.resolve(this.packedValuesCache.pack(args));
+  }
+
+  /**
+   * Pack the given returns.
+   * @param returns - Returns to pack
+   */
+  public packReturns(returns: Fr[]): Promise<Fr> {
+    return Promise.resolve(this.packedValuesCache.pack(returns));
+  }
+
+  /**
+   * Unpack the given returns.
+   * @param returnsHash - Returns hash to unpack
+   */
+  public unpackReturns(returnsHash: Fr): Promise<Fr[]> {
+    return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
   }
 
   /**
@@ -375,7 +391,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       derivedCallContext,
       this.historicalHeader,
       this.authWitnesses,
-      this.packedArgsCache,
+      this.packedValuesCache,
       this.noteCache,
       this.db,
       this.curve,
@@ -428,7 +444,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       isDelegateCall,
       isStaticCall,
     );
-    const args = this.packedArgsCache.unpack(argsHash);
+    const args = this.packedValuesCache.unpack(argsHash);
     const enqueuedRequest = PublicCallRequest.from({
       args,
       callContext: derivedCallContext,
@@ -472,9 +488,12 @@ export class ClientExecutionContext extends ViewDataOracle {
       isDelegateCall ? this.contractAddress : targetContractAddress,
       portalContractAddress,
       FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
+      this.callContext.gasLeft, // TODO(palla/gas): We should deduct DA and L1 gas used for the derived context
       isDelegateCall,
       isStaticCall,
       startSideEffectCounter,
+      this.callContext.gasSettings,
+      this.callContext.transactionFee,
     );
   }
 

package/src/client/private_execution.ts

@@ -4,7 +4,7 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import { extractReturnWitness } from '../acvm/deserialize.js';
+import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
@@ -26,7 +26,7 @@ export async function executePrivateFunction(
   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(
+  const acirExecutionResult = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
     (err: Error) => {
       throw new ExecutionError(
         err.message,
@@ -39,8 +39,8 @@ export async function executePrivateFunction(
       );
     },
   );
-
-  const returnWitness = extractReturnWitness(acir, partialWitness);
+  const partialWitness = acirExecutionResult.partialWitness;
+  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
   const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
 
   const encryptedLogs = context.getEncryptedLogs();
@@ -55,9 +55,10 @@ export async function executePrivateFunction(
 
   // Mocking the return type to be an array of 4 fields
   // TODO: @LHerskind must be updated as we are progressing with the macros to get the information
-  const returnTypes: AbiType[] = [{ kind: 'array', length: 4, type: { kind: 'field' } }];
+  const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
+  const returnTypes: AbiType[] = [{ kind: 'array', length: rawReturnValues.length, type: { kind: 'field' } }];
   const mockArtifact = { ...artifact, returnTypes };
-  const returnValues = decodeReturnValues(mockArtifact, publicInputs.returnValues);
+  const returnValues = decodeReturnValues(mockArtifact, rawReturnValues);
 
   const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
     publicInputs.noteHashReadRequests,

package/src/client/simulator.ts

@@ -16,7 +16,7 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type WasmBlackBoxFunctionSolver, createBlackBoxSolver } from '@noir-lang/acvm_js';
 
 import { createSimulationError } from '../common/errors.js';
-import { PackedArgsCache } from '../common/packed_args_cache.js';
+import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { ClientExecutionContext } from './client_execution_context.js';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
@@ -89,14 +89,18 @@ export class AcirSimulator {
     // reserve the first side effect for the tx hash (inserted by the private kernel)
     const startSideEffectCounter = 1;
 
+    const transactionFee = Fr.ZERO;
     const callContext = new CallContext(
       msgSender,
       contractAddress,
       portalContractAddress,
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
+      request.gasSettings.getInitialAvailable(),
       false,
       false,
       startSideEffectCounter,
+      request.gasSettings,
+      transactionFee,
     );
     const context = new ClientExecutionContext(
       contractAddress,
@@ -105,7 +109,7 @@ export class AcirSimulator {
       callContext,
       header,
       request.authWitnesses,
-      PackedArgsCache.create(request.packedArguments),
+      PackedValuesCache.create(request.packedArguments),
       new ExecutionNoteCache(),
       this.db,
       curve,
@@ -194,7 +198,7 @@ export class AcirSimulator {
     const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
     if (maxNoteFields < note.items.length) {
       throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please consider increasing the allowed field size to accommodate all notes generated from the contract.`,
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
       );
     }
 

package/src/client/unconstrained_execution.ts

@@ -4,7 +4,7 @@ import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import { extractReturnWitness } from '../acvm/deserialize.js';
+import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { AcirSimulator } from './simulator.js';
@@ -27,7 +27,7 @@ export async function executeUnconstrainedFunction(
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
-  const { partialWitness } = await acvm(
+  const acirExecutionResult = await acvm(
     await AcirSimulator.getSolver(),
     acir,
     initialWitness,
@@ -44,6 +44,7 @@ export async function executeUnconstrainedFunction(
     );
   });
 
-  return decodeReturnValues(artifact, extractReturnWitness(acir, partialWitness));
+  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
+  return decodeReturnValues(artifact, returnWitness);
 }
 // docs:end:execute_unconstrained_function

package/src/common/index.ts

@@ -1,3 +1,3 @@
-export * from './packed_args_cache.js';
+export * from './packed_values_cache.js';
 export * from './errors.js';
 export * from './side_effect_counter.js';

package/src/common/packed_values_cache.ts

@@ -0,0 +1,55 @@
+import { PackedValues } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+
+/**
+ * A cache for packed values (arguments, returns) during transaction execution.
+ */
+export class PackedValuesCache {
+  private cache: Map<bigint, Fr[]>;
+
+  constructor(initialArguments: PackedValues[] = []) {
+    this.cache = new Map();
+    for (const initialArg of initialArguments) {
+      this.cache.set(initialArg.hash.toBigInt(), initialArg.values);
+    }
+  }
+
+  /**
+   * Creates a new packed values cache.
+   * @param initialArguments - The initial arguments to add to the cache.
+   * @returns The new packed values cache.
+   */
+  public static create(initialArguments: PackedValues[] = []) {
+    return new PackedValuesCache(initialArguments);
+  }
+
+  /**
+   * Unpacks packed values.
+   * @param hash - The hash of the packed values.
+   * @returns The unpacked values.
+   */
+  public unpack(hash: Fr): Fr[] {
+    if (hash.equals(Fr.ZERO)) {
+      return [];
+    }
+    const packedValues = this.cache.get(hash.value);
+    if (!packedValues) {
+      throw new Error(`Packed values for hash ${hash.toString()} not found in cache`);
+    }
+    return packedValues;
+  }
+
+  /**
+   * Packs values.
+   * @param values - The values to pack.
+   * @returns The hash of the packed values.
+   */
+  public pack(values: Fr[]) {
+    if (values.length === 0) {
+      return Fr.ZERO;
+    }
+    const packedValues = PackedValues.fromValues(values);
+    this.cache.set(packedValues.hash.value, packedValues.values);
+    return packedValues.hash;
+  }
+}

package/src/index.ts

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