@aztec/simulator 0.57.0 → 0.59.0

package/src/avm/opcodes/comparators.ts

@@ -12,7 +12,7 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const operands = [this.aOffset, this.bOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(this.inTag, aOffset, bOffset);
+    memory.checkTagsAreSame(aOffset, bOffset);
 
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);

package/src/avm/opcodes/contract.ts

@@ -39,12 +39,13 @@ export class GetContractInstance extends Instruction {
       instance.deployer.toField(),
       instance.contractClassId,
       instance.initializationHash,
-      instance.publicKeysHash,
+      // This this okay ?
+      ...instance.publicKeys.toFields(),
     ].map(f => new Field(f));
 
     memory.setSlice(dstOffset, data);
 
-    memory.assert({ reads: 1, writes: 6, addressing });
+    memory.assert({ reads: 1, writes: 17, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/control_flow.ts

@@ -63,7 +63,7 @@ export class InternalCall extends Instruction {
   static readonly type: string = 'INTERNALCALL';
   static readonly opcode: Opcode = Opcode.INTERNALCALL;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT16];
 
   constructor(private loc: number) {
     super();

package/src/avm/opcodes/conversion.ts

@@ -13,10 +13,10 @@ export class ToRadixLE extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
-    OperandType.UINT32, // src memory address
-    OperandType.UINT32, // dst memory address
-    OperandType.UINT32, // radix memory address
-    OperandType.UINT32, // number of limbs (Immediate)
+    OperandType.UINT16, // src memory address
+    OperandType.UINT16, // dst memory address
+    OperandType.UINT16, // radix memory address
+    OperandType.UINT16, // number of limbs (Immediate)
     OperandType.UINT8, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
   ];
 

package/src/avm/opcodes/ec_add.ts

@@ -15,13 +15,13 @@ export class EcAdd extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // reserved
     OperandType.UINT16, // indirect
-    OperandType.UINT32, // p1X
-    OperandType.UINT32, // p1Y
-    OperandType.UINT32, // p1IsInfinite
-    OperandType.UINT32, // p2X
-    OperandType.UINT32, // p2Y
-    OperandType.UINT32, // p2IsInfinite
-    OperandType.UINT32, // dst
+    OperandType.UINT16, // p1X
+    OperandType.UINT16, // p1Y
+    OperandType.UINT16, // p1IsInfinite
+    OperandType.UINT16, // p2X
+    OperandType.UINT16, // p2Y
+    OperandType.UINT16, // p2IsInfinite
+    OperandType.UINT16, // dst
   ];
 
   constructor(
@@ -72,7 +72,14 @@ export class EcAdd extends Instruction {
     }
 
     const grumpkin = new Grumpkin();
-    let dest = grumpkin.add(p1, p2);
+    let dest;
+    if (p1IsInfinite) {
+      dest = p2;
+    } else if (p2IsInfinite) {
+      dest = p1;
+    } else {
+      dest = grumpkin.add(p1, p2);
+    }
     // Temporary,
     if (p1IsInfinite) {
       dest = p2;

package/src/avm/opcodes/external_calls.ts

@@ -16,14 +16,14 @@ abstract class ExternalCall extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT16, // Indirect
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(
@@ -164,8 +164,8 @@ export class Return extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(private indirect: number, private returnOffset: number, private copySize: number) {

package/src/avm/opcodes/hashing.ts

@@ -23,8 +23,8 @@ export class Poseidon2 extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
@@ -106,9 +106,9 @@ export class KeccakF1600 extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(
@@ -153,9 +153,9 @@ export class Sha256Compression extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(

package/src/avm/opcodes/instruction_impl.ts

@@ -8,10 +8,8 @@ export const ThreeOperandWireFormat8 = [
   OperandType.UINT8,
   OperandType.UINT8,
   OperandType.UINT8,
-  OperandType.UINT8,
 ];
 export const ThreeOperandWireFormat16 = [
-  OperandType.UINT8,
   OperandType.UINT8,
   OperandType.UINT8,
   OperandType.UINT16,
@@ -29,7 +27,6 @@ export abstract class ThreeOperandInstruction extends Instruction {
 
   constructor(
     protected indirect: number,
-    protected inTag: number,
     protected aOffset: number,
     protected bOffset: number,
     protected dstOffset: number,

package/src/avm/opcodes/memory.ts

@@ -163,9 +163,9 @@ export class CalldataCopy extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(

package/src/avm/opcodes/misc.ts

@@ -15,10 +15,10 @@ export class DebugLog extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
-    OperandType.UINT32, // message memory address
-    OperandType.UINT32, // message size
-    OperandType.UINT32, // fields memory address
-    OperandType.UINT32, // fields size address
+    OperandType.UINT16, // message memory address
+    OperandType.UINT16, // message size
+    OperandType.UINT16, // fields memory address
+    OperandType.UINT16, // fields size address
   ];
 
   constructor(

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -16,10 +16,10 @@ export class MultiScalarMul extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8 /* opcode */,
     OperandType.UINT8 /* indirect */,
-    OperandType.UINT32 /* points vector offset */,
-    OperandType.UINT32 /* scalars vector offset */,
-    OperandType.UINT32 /* output offset (fixed triplet) */,
-    OperandType.UINT32 /* points length offset */,
+    OperandType.UINT16 /* points vector offset */,
+    OperandType.UINT16 /* scalars vector offset */,
+    OperandType.UINT16 /* output offset (fixed triplet) */,
+    OperandType.UINT16 /* points length offset */,
   ];
 
   constructor(
@@ -69,10 +69,8 @@ export class MultiScalarMul extends Instruction {
     // Now we need to reconstruct the points and scalars into something we can operate on.
     const grumpkinPoints: Point[] = [];
     for (let i = 0; i < numPoints; i++) {
-      const p: Point = new Point(pointsVector[3 * i].toFr(), pointsVector[3 * i + 1].toFr(), false);
-      // Include this later when we have a standard for representing infinity
-      // const isInf = pointsVector[i + 2].toBoolean();
-
+      const isInf = pointsVector[3 * i + 2].toNumber() === 1;
+      const p: Point = new Point(pointsVector[3 * i].toFr(), pointsVector[3 * i + 1].toFr(), isInf);
       if (!p.isOnGrumpkin()) {
         throw new InstructionExecutionError(`Point ${p.toString()} is not on the curve.`);
       }
@@ -93,10 +91,20 @@ export class MultiScalarMul extends Instruction {
     const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
     // Fold the points and scalars into a single point
     // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
-    const outputPoint = rest.reduce(
-      (acc, curr) => grumpkin.add(acc, grumpkin.mul(curr[0], curr[1])),
-      grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]),
-    );
+    const outputPoint = rest.reduce((acc, curr) => {
+      if (curr[1] === Fq.ZERO) {
+        // If we multiply by 0, the result will the point at infinity - so we ignore it
+        return acc;
+      } else if (curr[0].inf) {
+        // If we multiply the point at infinity by a scalar, it's still the point at infinity
+        return acc;
+      } else if (acc.inf) {
+        // If we accumulator is the point at infinity, we can just return the current point
+        return curr[0];
+      } else {
+        return grumpkin.add(acc, grumpkin.mul(curr[0], curr[1]));
+      }
+    }, grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]));
     const output = outputPoint.toFields().map(f => new Field(f));
 
     memory.setSlice(outputOffset, output);

package/src/avm/opcodes/storage.ts

@@ -10,8 +10,8 @@ abstract class BaseStorageInstruction extends Instruction {
   public static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(protected indirect: number, protected aOffset: number, protected bOffset: number) {

package/src/avm/serialization/instruction_serialization.ts

@@ -158,7 +158,7 @@ function writeBigInt128BE(this: Buffer, value: bigint): void {
  */
 export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[] {
   const argValues = [];
-  if (cursor instanceof Buffer) {
+  if (Buffer.isBuffer(cursor)) {
     cursor = new BufferCursor(cursor);
   }
 

package/src/avm/test_utils.ts

@@ -1,5 +1,4 @@
-import { Fr } from '@aztec/circuits.js';
-import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+import { type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
 
 import { type jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';

package/src/client/client_execution_context.ts

@@ -17,6 +17,7 @@ import {
   CallContext,
   FunctionSelector,
   type Header,
+  PRIVATE_CONTEXT_INPUTS_LENGTH,
   PUBLIC_DISPATCH_SELECTOR,
   PrivateContextInputs,
   type TxContext,
@@ -108,8 +109,12 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.txContext,
       this.sideEffectCounter,
     );
+    const privateContextInputsAsFields = privateContextInputs.toFields();
+    if (privateContextInputsAsFields.length !== PRIVATE_CONTEXT_INPUTS_LENGTH) {
+      throw new Error('Invalid private context inputs size');
+    }
 
-    const fields = [...privateContextInputs.toFields(), ...args];
+    const fields = [...privateContextInputsAsFields, ...args];
     return toACVMWitness(0, fields);
   }
 

package/src/client/db_oracle.ts

@@ -5,11 +5,15 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type CompleteAddress, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
+import {
+  type CompleteAddress,
+  type ContractInstance,
+  type Header,
+  type KeyValidationRequest,
+} from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
-import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData } from '../acvm/index.js';
 import { type CommitmentsDB } from '../public/db_interfaces.js';

package/src/client/index.ts

@@ -2,3 +2,4 @@ export * from './simulator.js';
 export * from './db_oracle.js';
 export * from './pick_notes.js';
 export * from './execution_note_cache.js';
+export { extractPrivateCircuitPublicInputs } from './private_execution.js';

package/src/client/private_execution.ts

@@ -1,13 +1,20 @@
 import { PrivateExecutionResult } from '@aztec/circuit-types';
 import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
-import { Fr, FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import type { FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
+import {
+  Fr,
+  FunctionData,
+  PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,
+  PRIVATE_CONTEXT_INPUTS_LENGTH,
+  PrivateCallStackItem,
+  PrivateCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type FunctionArtifact, type FunctionSelector, countArgumentsSize } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 
-import { witnessMapToFields } from '../acvm/deserialize.js';
-import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
+import { fromACVMField, witnessMapToFields } from '../acvm/deserialize.js';
+import { type ACVMWitness, Oracle, acvm, extractCallStack } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
 
@@ -40,8 +47,7 @@ export async function executePrivateFunction(
   });
   const duration = timer.ms();
   const partialWitness = acirExecutionResult.partialWitness;
-  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-  const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
+  const publicInputs = extractPrivateCircuitPublicInputs(artifact, partialWitness);
 
   // TODO (alexg) estimate this size
   const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
@@ -92,3 +98,27 @@ export async function executePrivateFunction(
     unencryptedLogs,
   );
 }
+
+/**
+ * Get the private circuit public inputs from the partial witness.
+ * @param artifact - The function artifact
+ * @param partialWitness - The partial witness, result of simulating the function.
+ * @returns - The public inputs.
+ */
+export function extractPrivateCircuitPublicInputs(
+  artifact: FunctionArtifact,
+  partialWitness: ACVMWitness,
+): PrivateCircuitPublicInputs {
+  const parametersSize = countArgumentsSize(artifact) + PRIVATE_CONTEXT_INPUTS_LENGTH;
+  const returnsSize = PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH;
+  const returnData = [];
+  // Return values always appear in the witness after arguments.
+  for (let i = parametersSize; i < parametersSize + returnsSize; i++) {
+    const returnedField = partialWitness.get(i);
+    if (returnedField === undefined) {
+      throw new Error(`Missing return value for index ${i}`);
+    }
+    returnData.push(fromACVMField(returnedField));
+  }
+  return PrivateCircuitPublicInputs.fromFields(returnData);
+}

package/src/client/view_data_oracle.ts

@@ -7,12 +7,11 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type Header, type KeyValidationRequest } from '@aztec/circuits.js';
+import { type ContractInstance, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
-import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData, TypedOracle } from '../acvm/index.js';
 import { type DBOracle } from './db_oracle.js';

package/src/public/db_interfaces.ts

@@ -1,8 +1,11 @@
 import { type NullifierMembershipWitness } from '@aztec/circuit-types';
-import { type FunctionSelector, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import {
+  type ContractInstanceWithAddress,
+  type FunctionSelector,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
+} from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
-import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { type MessageLoadOracleInputs } from '../acvm/index.js';
 

package/src/public/dual_side_effect_trace.ts

@@ -0,0 +1,173 @@
+import {
+  type CombinedConstantData,
+  type ContractInstanceWithAddress,
+  type Gas,
+  type VMCircuitPublicInputs,
+} from '@aztec/circuits.js';
+import { type Fr } from '@aztec/foundation/fields';
+
+import { assert } from 'console';
+
+import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
+import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { type PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
+import { type PublicExecutionResult } from './execution.js';
+import { type PublicSideEffectTrace } from './side_effect_trace.js';
+import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
+
+export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
+
+export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
+  constructor(
+    public readonly innerCallTrace: PublicSideEffectTrace,
+    public readonly enqueuedCallTrace: PublicEnqueuedCallSideEffectTrace,
+  ) {}
+
+  public fork() {
+    return new DualSideEffectTrace(this.innerCallTrace.fork(), this.enqueuedCallTrace.fork());
+  }
+
+  public getCounter() {
+    assert(this.innerCallTrace.getCounter() == this.enqueuedCallTrace.getCounter());
+    return this.innerCallTrace.getCounter();
+  }
+
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
+    this.innerCallTrace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
+    this.enqueuedCallTrace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
+  }
+
+  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
+    this.innerCallTrace.tracePublicStorageWrite(storageAddress, slot, value);
+    this.enqueuedCallTrace.tracePublicStorageWrite(storageAddress, slot, value);
+  }
+
+  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
+  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
+    this.innerCallTrace.traceNoteHashCheck(_storageAddress, noteHash, leafIndex, exists);
+    this.enqueuedCallTrace.traceNoteHashCheck(_storageAddress, noteHash, leafIndex, exists);
+  }
+
+  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+    this.innerCallTrace.traceNewNoteHash(_storageAddress, noteHash);
+    this.enqueuedCallTrace.traceNewNoteHash(_storageAddress, noteHash);
+  }
+
+  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean) {
+    this.innerCallTrace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
+    this.enqueuedCallTrace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
+  }
+
+  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
+    this.innerCallTrace.traceNewNullifier(storageAddress, nullifier);
+    this.enqueuedCallTrace.traceNewNullifier(storageAddress, nullifier);
+  }
+
+  public traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
+    this.innerCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists);
+    this.enqueuedCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists);
+  }
+
+  public traceNewL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr) {
+    this.innerCallTrace.traceNewL2ToL1Message(contractAddress, recipient, content);
+    this.enqueuedCallTrace.traceNewL2ToL1Message(contractAddress, recipient, content);
+  }
+
+  public traceUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+    this.innerCallTrace.traceUnencryptedLog(contractAddress, log);
+    this.enqueuedCallTrace.traceUnencryptedLog(contractAddress, log);
+  }
+
+  public traceGetContractInstance(instance: TracedContractInstance) {
+    this.innerCallTrace.traceGetContractInstance(instance);
+    this.enqueuedCallTrace.traceGetContractInstance(instance);
+  }
+
+  /**
+   * Trace a nested call.
+   * Accept some results from a finished nested call's trace into this one.
+   */
+  public traceNestedCall(
+    /** The trace of the nested call. */
+    nestedCallTrace: this,
+    /** The execution environment of the nested call. */
+    nestedEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** Bytecode used for this execution. */
+    bytecode: Buffer,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+    /** Function name for logging */
+    functionName: string = 'unknown',
+  ) {
+    this.innerCallTrace.traceNestedCall(
+      nestedCallTrace.innerCallTrace,
+      nestedEnvironment,
+      startGasLeft,
+      endGasLeft,
+      bytecode,
+      avmCallResults,
+      functionName,
+    );
+    this.enqueuedCallTrace.traceNestedCall(
+      nestedCallTrace.enqueuedCallTrace,
+      nestedEnvironment,
+      startGasLeft,
+      endGasLeft,
+      bytecode,
+      avmCallResults,
+      functionName,
+    );
+  }
+
+  /**
+   * Convert this trace to a PublicExecutionResult for use externally to the simulator.
+   */
+  public toPublicExecutionResult(
+    /** The execution environment of the nested call. */
+    avmEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** Bytecode used for this execution. */
+    bytecode: Buffer,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+    /** Function name for logging */
+    functionName: string = 'unknown',
+  ): PublicExecutionResult {
+    return this.innerCallTrace.toPublicExecutionResult(
+      avmEnvironment,
+      startGasLeft,
+      endGasLeft,
+      bytecode,
+      avmCallResults,
+      functionName,
+    );
+  }
+
+  public toVMCircuitPublicInputs(
+    /** Constants */
+    constants: CombinedConstantData,
+    /** The execution environment of the nested call. */
+    avmEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+  ): VMCircuitPublicInputs {
+    return this.enqueuedCallTrace.toVMCircuitPublicInputs(
+      constants,
+      avmEnvironment,
+      startGasLeft,
+      endGasLeft,
+      avmCallResults,
+    );
+  }
+}