@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/tx/global_variables.ts

@@ -2,7 +2,13 @@ import { GLOBAL_VARIABLES_LENGTH } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt64BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -11,6 +17,7 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { schemas } from '../schemas/index.js';
+import type { UInt32, UInt64 } from '../types/index.js';
 
 /**
  * Global variables of the L2 block.
@@ -22,11 +29,11 @@ export class GlobalVariables {
     /** Version for the L2 block. */
     public version: Fr,
     /** Block number of the L2 block. */
-    public blockNumber: Fr,
+    public blockNumber: UInt32,
     /** Slot number of the L2 block */
     public slotNumber: Fr,
     /** Timestamp of the L2 block. */
-    public timestamp: Fr,
+    public timestamp: UInt64,
     /** Recipient of block reward. */
     public coinbase: EthAddress,
     /** Address to receive fees. */
@@ -40,9 +47,9 @@ export class GlobalVariables {
       .object({
         chainId: schemas.Fr,
         version: schemas.Fr,
-        blockNumber: schemas.Fr,
+        blockNumber: schemas.UInt32,
         slotNumber: schemas.Fr,
-        timestamp: schemas.Fr,
+        timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
         gasFees: GasFees.schema,
@@ -60,9 +67,9 @@ export class GlobalVariables {
 
   static empty(fields: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
     return GlobalVariables.from({
-      blockNumber: Fr.ZERO,
+      blockNumber: 0,
       slotNumber: Fr.ZERO,
-      timestamp: Fr.ZERO,
+      timestamp: 0n,
       chainId: Fr.ZERO,
       version: Fr.ZERO,
       coinbase: EthAddress.ZERO,
@@ -77,9 +84,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
+      reader.readNumber(),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
       reader.readObject(GasFees),
@@ -92,9 +99,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       reader.readField(),
       reader.readField(),
+      reader.readU32(),
       reader.readField(),
-      reader.readField(),
-      reader.readField(),
+      reader.readField().toBigInt(),
       EthAddress.fromField(reader.readField()),
       AztecAddress.fromField(reader.readField()),
       GasFees.fromFields(reader),
@@ -102,7 +109,7 @@ export class GlobalVariables {
   }
 
   static getFields(fields: FieldsOf<GlobalVariables>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return [
       fields.chainId,
       fields.version,
@@ -116,7 +123,16 @@ export class GlobalVariables {
   }
 
   toBuffer() {
-    return serializeToBuffer(...GlobalVariables.getFields(this));
+    return serializeToBuffer([
+      this.chainId,
+      this.version,
+      this.blockNumber,
+      this.slotNumber,
+      bigintToUInt64BE(this.timestamp),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+    ]);
   }
 
   toFields() {
@@ -135,7 +151,7 @@ export class GlobalVariables {
    */
   toFriendlyJSON() {
     return {
-      blockNumber: this.blockNumber.toNumber(),
+      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
       timestamp: this.timestamp.toString(),
       coinbase: this.coinbase.toString(),
@@ -151,9 +167,9 @@ export class GlobalVariables {
     return (
       this.chainId.isZero() &&
       this.version.isZero() &&
-      this.blockNumber.isZero() &&
+      this.blockNumber === 0 &&
       this.slotNumber.isZero() &&
-      this.timestamp.isZero() &&
+      this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
       this.gasFees.isEmpty()
@@ -164,13 +180,13 @@ export class GlobalVariables {
     return {
       chainId: this.chainId.toNumber(),
       version: this.version.toNumber(),
-      blockNumber: this.blockNumber.toNumber(),
+      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
-      timestamp: this.timestamp.toNumber(),
+      timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
-      feePerDaGas: this.gasFees.feePerDaGas.toNumber(),
-      feePerL2Gas: this.gasFees.feePerL2Gas.toNumber(),
+      feePerDaGas: Number(this.gasFees.feePerDaGas),
+      feePerL2Gas: Number(this.gasFees.feePerL2Gas),
     };
   }
 
@@ -182,9 +198,9 @@ export class GlobalVariables {
     return (
       this.chainId.equals(other.chainId) &&
       this.version.equals(other.version) &&
-      this.blockNumber.equals(other.blockNumber) &&
+      this.blockNumber === other.blockNumber &&
       this.slotNumber.equals(other.slotNumber) &&
-      this.timestamp.equals(other.timestamp) &&
+      this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
       this.gasFees.equals(other.gasFees)

package/src/tx/hashed_values.ts

@@ -1,9 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { computeVarArgsHash } from '../hash/index.js';
+import { computeCalldataHash, computeVarArgsHash } from '../hash/index.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
 import { Vector } from '../types/index.js';
 
@@ -11,7 +12,7 @@ import { Vector } from '../types/index.js';
  * A container for storing a list of values and their hash.
  */
 export class HashedValues {
-  private constructor(
+  constructor(
     /**
      *  Raw values.
      */
@@ -22,20 +23,29 @@ export class HashedValues {
     public readonly hash: Fr,
   ) {}
 
+  getSize() {
+    return this.values.length + 1 /* hash */;
+  }
+
   static get schema(): ZodFor<HashedValues> {
-    return z.array(schemas.Fr).transform(HashedValues.fromValues);
+    return z
+      .object({
+        values: z.array(schemas.Fr),
+        hash: schemas.Fr,
+      })
+      .transform(HashedValues.from);
   }
 
-  toJSON() {
-    return this.values;
+  static from(fields: FieldsOf<HashedValues>): HashedValues {
+    return new HashedValues(...HashedValues.getFields(fields));
   }
 
-  static random() {
-    return HashedValues.fromValues([Fr.random(), Fr.random()]);
+  static getFields(fields: FieldsOf<HashedValues>) {
+    return [fields.values, fields.hash] as const;
   }
 
-  static async fromValues(values: Fr[]) {
-    return new HashedValues(values, await computeVarArgsHash(values));
+  static random() {
+    return new HashedValues([Fr.random(), Fr.random()], Fr.random());
   }
 
   toBuffer() {
@@ -46,4 +56,14 @@ export class HashedValues {
     const reader = BufferReader.asReader(buffer);
     return new HashedValues(reader.readVector(Fr), Fr.fromBuffer(reader));
   }
+
+  // Computes the hash of input arguments or return values for private functions, or for authwit creation.
+  static async fromArgs(args: Fr[]) {
+    return new HashedValues(args, await computeVarArgsHash(args));
+  }
+
+  // Computes the hash of calldata for public functions.
+  static async fromCalldata(calldata: Fr[]) {
+    return new HashedValues(calldata, await computeCalldataHash(calldata));
+  }
 }

package/src/tx/index.ts

@@ -1,7 +1,6 @@
 export * from './block_header.js';
 export * from './call_context.js';
 export * from './global_variables.js';
-export * from './max_block_number.js';
 export * from './content_commitment.js';
 export * from './state_reference.js';
 export * from './partial_state_reference.js';
@@ -11,17 +10,23 @@ export * from './tx_constant_data.js';
 export * from './tx_context.js';
 export * from './tx_request.js';
 export * from './private_execution_result.js';
-export * from './public_execution_request.js';
+export * from './proposed_block_header.js';
+export * from './public_call_request_with_calldata.js';
 export * from './tx_hash.js';
 export * from './tx_receipt.js';
 export * from './tx.js';
 export * from './processed_tx.js';
+export * from './proven_tx.js';
 export * from './simulated_tx.js';
 export * from './tx_effect.js';
 export * from './public_simulation_output.js';
 export * from './tx_execution_request.js';
 export * from './validator/tx_validator.js';
 export * from './validator/empty_validator.js';
+export * from './validator/error_texts.js';
 export * from './capsule.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
+export * from './indexed_tx_effect.js';
+export * from './offchain_effect.js';
+export * from './profiling.js';

package/src/tx/indexed_tx_effect.ts

@@ -0,0 +1,39 @@
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { L2BlockHash } from '../block/block_hash.js';
+import { type InBlock, inBlockSchemaFor, randomInBlock } from '../block/in_block.js';
+import { TxEffect } from './tx_effect.js';
+
+export type IndexedTxEffect = InBlock<TxEffect> & { txIndexInBlock: number };
+
+export function indexedTxSchema() {
+  return inBlockSchemaFor(TxEffect.schema).extend({ txIndexInBlock: schemas.Integer });
+}
+
+export async function randomIndexedTxEffect(): Promise<IndexedTxEffect> {
+  return {
+    ...randomInBlock(await TxEffect.random()),
+    txIndexInBlock: Math.floor(Math.random() * 1000),
+  };
+}
+
+export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
+  return serializeToBuffer(effect.l2BlockHash, effect.l2BlockNumber, effect.txIndexInBlock, effect.data);
+}
+
+export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
+  const reader = BufferReader.asReader(buffer);
+
+  const l2BlockHash = reader.readObject(L2BlockHash);
+  const l2BlockNumber = reader.readNumber();
+  const txIndexInBlock = reader.readNumber();
+  const data = reader.readObject(TxEffect);
+
+  return {
+    l2BlockHash,
+    l2BlockNumber,
+    txIndexInBlock,
+    data,
+  };
+}

package/src/tx/offchain_effect.ts

@@ -0,0 +1,20 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+// The following identifier was copied over from `noir-projects/aztec-nr/aztec/src/messages/offchain_messages.nr`.
+// poseidon2hash("aztecnr_offchain_message")
+export const OFFCHAIN_MESSAGE_IDENTIFIER: Fr = new Fr(
+  6023466688192654631553769360478808766602235351827869819420284624004071427516n,
+);
+
+/**
+ * Represents an offchain effect emitted via the `emit_offchain_effect` oracle (see the oracle documentation for
+ * more details).
+ */
+export type OffchainEffect = {
+  /** The emitted data */
+  data: Fr[];
+  /** The contract that emitted the data */
+  contractAddress: AztecAddress;
+};

package/src/tx/partial_state_reference.ts

@@ -1,4 +1,5 @@
 import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import type { ViemPartialStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -55,11 +56,43 @@ export class PartialStateReference {
     return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
   }
 
+  static fromViem(stateReference: ViemPartialStateReference) {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.fromViem(stateReference.noteHashTree),
+      AppendOnlyTreeSnapshot.fromViem(stateReference.nullifierTree),
+      AppendOnlyTreeSnapshot.fromViem(stateReference.publicDataTree),
+    );
+  }
+
+  static random(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    );
+  }
+
+  toViem(): ViemPartialStateReference {
+    return {
+      noteHashTree: this.noteHashTree.toViem(),
+      nullifierTree: this.nullifierTree.toViem(),
+      publicDataTree: this.publicDataTree.toViem(),
+    };
+  }
+
+  toAbi(): [
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+    ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
+  ] {
+    return [this.noteHashTree.toAbi(), this.nullifierTree.toAbi(), this.publicDataTree.toAbi()];
+  }
+
   static empty(): PartialStateReference {
     return new PartialStateReference(
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
     );
   }
 
@@ -82,7 +115,7 @@ export class PartialStateReference {
   }
 
   isEmpty(): boolean {
-    return this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+    return this.noteHashTree.isEmpty() && this.nullifierTree.isEmpty() && this.publicDataTree.isEmpty();
   }
 
   public equals(other: this): boolean {

package/src/tx/private_execution_result.ts

@@ -9,10 +9,12 @@ import { NoteSelector } from '../abi/note_selector.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
-import { PublicExecutionRequest } from './public_execution_request.js';
+import type { UInt32 } from '../types/index.js';
+import { HashedValues } from './hashed_values.js';
+import type { OffchainEffect } from './offchain_effect.js';
 
 /**
  * The contents of a new note.
@@ -47,7 +49,10 @@ export class NoteAndSlot {
 }
 
 export class CountedContractClassLog implements IsEmpty {
-  constructor(public log: ContractClassLog, public counter: number) {}
+  constructor(
+    public log: ContractClassLog,
+    public counter: number,
+  ) {}
 
   static get schema(): ZodFor<CountedContractClassLog> {
     return z
@@ -67,36 +72,13 @@ export class CountedContractClassLog implements IsEmpty {
   }
 }
 
-export class CountedPublicExecutionRequest {
-  constructor(public request: PublicExecutionRequest, public counter: number) {}
-
-  static get schema(): ZodFor<CountedPublicExecutionRequest> {
-    return z
-      .object({
-        request: PublicExecutionRequest.schema,
-        counter: schemas.Integer,
-      })
-      .transform(CountedPublicExecutionRequest.from);
-  }
-
-  static from(fields: FieldsOf<CountedPublicExecutionRequest>) {
-    return new CountedPublicExecutionRequest(fields.request, fields.counter);
-  }
-
-  isEmpty(): boolean {
-    return this.request.isEmpty() && !this.counter;
-  }
-
-  static async random() {
-    return new CountedPublicExecutionRequest(await PublicExecutionRequest.random(), 0);
-  }
-}
-
 export class PrivateExecutionResult {
   constructor(
     public entrypoint: PrivateCallExecutionResult,
     /** The first non revertible nullifier, or zero if there was none. */
     public firstNullifier: Fr,
+    /** An array of calldata for the enqueued public function calls and the teardown function call. */
+    public publicFunctionCalldata: HashedValues[],
   ) {}
 
   static get schema(): ZodFor<PrivateExecutionResult> {
@@ -104,16 +86,27 @@ export class PrivateExecutionResult {
       .object({
         entrypoint: PrivateCallExecutionResult.schema,
         firstNullifier: schemas.Fr,
+        publicFunctionCalldata: z.array(HashedValues.schema),
       })
       .transform(PrivateExecutionResult.from);
   }
 
   static from(fields: FieldsOf<PrivateExecutionResult>) {
-    return new PrivateExecutionResult(fields.entrypoint, fields.firstNullifier);
+    return new PrivateExecutionResult(fields.entrypoint, fields.firstNullifier, fields.publicFunctionCalldata);
   }
 
   static async random(nested = 1): Promise<PrivateExecutionResult> {
-    return new PrivateExecutionResult(await PrivateCallExecutionResult.random(nested), Fr.random());
+    return new PrivateExecutionResult(await PrivateCallExecutionResult.random(nested), Fr.random(), [
+      HashedValues.random(),
+      HashedValues.random(),
+    ]);
+  }
+
+  /**
+   * The block number that this execution was simulated with.
+   */
+  getSimulationBlockNumber(): UInt32 {
+    return this.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber;
   }
 }
 
@@ -140,17 +133,17 @@ export class PrivateCallExecutionResult {
     public noteHashNullifierCounterMap: Map<number, number>,
     /** The raw return values of the executed function. */
     public returnValues: Fr[],
+    /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
+    public offchainEffects: { data: Fr[] }[],
     /** The nested executions. */
-    public nestedExecutions: PrivateCallExecutionResult[],
-    /** Enqueued public function execution requests to be picked up by the sequencer. */
-    public enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[],
-    /** Public function execution requested for teardown */
-    public publicTeardownFunctionCall: PublicExecutionRequest,
+    public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
      * Contract class logs emitted during execution of this function call.
-     * Note: These are preimages to `contractClassLogsHashes`.
+     * Note: We only need to collect the ContractClassLogFields as preimages for the tx.
+     * But keep them as ContractClassLog so that we can verify the log hashes before submitting the tx (TODO).
      */
     public contractClassLogs: CountedContractClassLog[],
+    public profileResult?: PrivateExecutionProfileResult,
   ) {}
 
   static get schema(): ZodFor<PrivateCallExecutionResult> {
@@ -164,9 +157,8 @@ export class PrivateCallExecutionResult {
         newNotes: z.array(NoteAndSlot.schema),
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
-        nestedExecutions: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
-        enqueuedPublicFunctionCalls: z.array(CountedPublicExecutionRequest.schema),
-        publicTeardownFunctionCall: PublicExecutionRequest.schema,
+        offchainEffects: z.array(z.object({ data: z.array(schemas.Fr) })),
+        nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
       .transform(PrivateCallExecutionResult.from);
@@ -182,9 +174,8 @@ export class PrivateCallExecutionResult {
       fields.newNotes,
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
-      fields.nestedExecutions,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
+      fields.offchainEffects,
+      fields.nestedExecutionResults,
       fields.contractClassLogs,
     );
   }
@@ -199,9 +190,12 @@ export class PrivateCallExecutionResult {
       [NoteAndSlot.random()],
       new Map([[0, 0]]),
       [Fr.random()],
+      [
+        {
+          data: [Fr.random()],
+        },
+      ],
       await timesParallel(nested, () => PrivateCallExecutionResult.random(0)),
-      [await CountedPublicExecutionRequest.random()],
-      await PublicExecutionRequest.random(),
       [new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))],
     );
   }
@@ -211,7 +205,7 @@ export function collectNoteHashLeafIndexMap(execResult: PrivateExecutionResult)
   const accum: Map<bigint, bigint> = new Map();
   const collectNoteHashLeafIndexMapRecursive = (callResult: PrivateCallExecutionResult, accum: Map<bigint, bigint>) => {
     callResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
-    callResult.nestedExecutions.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
+    callResult.nestedExecutionResults.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
   };
   collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
   return accum;
@@ -224,7 +218,7 @@ export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionR
     accum: Map<number, number>,
   ) => {
     callResult.noteHashNullifierCounterMap.forEach((value, key) => accum.set(key, value));
-    callResult.nestedExecutions.forEach(nested => collectNoteHashNullifierCounterMapRecursive(nested, accum));
+    callResult.nestedExecutionResults.forEach(nested => collectNoteHashNullifierCounterMapRecursive(nested, accum));
   };
   collectNoteHashNullifierCounterMapRecursive(execResult.entrypoint, accum);
   return accum;
@@ -236,7 +230,7 @@ export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionR
  * @returns All contract class logs.
  */
 function collectContractClassLogs(execResult: PrivateCallExecutionResult): CountedContractClassLog[] {
-  return [execResult.contractClassLogs, ...execResult.nestedExecutions.flatMap(collectContractClassLogs)].flat();
+  return [execResult.contractClassLogs, ...execResult.nestedExecutionResults.flatMap(collectContractClassLogs)].flat();
 }
 
 /**
@@ -244,58 +238,33 @@ function collectContractClassLogs(execResult: PrivateCallExecutionResult): Count
  * @param execResult - The topmost execution result.
  * @returns All contract class logs.
  */
-export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLog[] {
+export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLogFields[] {
   const allLogs = collectContractClassLogs(execResult.entrypoint);
   const sortedLogs = sortByCounter(allLogs);
-  return sortedLogs.map(l => l.log);
-}
-
-function collectEnqueuedCountedPublicExecutionRequests(
-  execResult: PrivateCallExecutionResult,
-): CountedPublicExecutionRequest[] {
-  return [
-    ...execResult.enqueuedPublicFunctionCalls,
-    ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests),
-  ];
+  return sortedLogs.map(l => l.log.fields);
 }
 
 /**
- * Collect all enqueued public function calls across all nested executions.
- * @param execResult - The topmost execution result.
- * @returns All enqueued public function calls.
+ * Collect all offchain effects emitted across all nested executions.
+ * @param execResult - The execution result to collect offchain effects from.
+ * @returns Array of offchain effects.
  */
-export function collectEnqueuedPublicFunctionCalls(execResult: PrivateExecutionResult): PublicExecutionRequest[] {
-  const countedRequests = collectEnqueuedCountedPublicExecutionRequests(execResult.entrypoint);
-  // without the reverse sort, the logs will be in a queue like fashion which is wrong
-  // as the kernel processes it like a stack, popping items off and pushing them to output
-  return sortByCounter(countedRequests, false).map(r => r.request);
-}
-
-export function collectPublicTeardownFunctionCall(execResult: PrivateExecutionResult): PublicExecutionRequest {
-  const collectPublicTeardownFunctionCallRecursive = (
-    callResult: PrivateCallExecutionResult,
-  ): PublicExecutionRequest[] => {
+export function collectOffchainEffects(execResult: PrivateExecutionResult): OffchainEffect[] {
+  const collectEffectsRecursive = (callResult: PrivateCallExecutionResult): OffchainEffect[] => {
     return [
-      callResult.publicTeardownFunctionCall,
-      ...callResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCallRecursive),
-    ].filter(call => !call.isEmpty());
+      ...callResult.offchainEffects.map(msg => ({
+        ...msg,
+        contractAddress: callResult.publicInputs.callContext.contractAddress, // contract that emitted the effect
+      })),
+      ...callResult.nestedExecutionResults.flatMap(nested => collectEffectsRecursive(nested)),
+    ];
   };
-  const teardownCalls = collectPublicTeardownFunctionCallRecursive(execResult.entrypoint);
-
-  if (teardownCalls.length === 1) {
-    return teardownCalls[0];
-  }
-
-  if (teardownCalls.length > 1) {
-    throw new Error('Multiple public teardown calls detected');
-  }
-
-  return PublicExecutionRequest.empty();
+  return collectEffectsRecursive(execResult.entrypoint);
 }
 
 export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {
   const collectFinalMinRevertibleSideEffectCounterRecursive = (callResult: PrivateCallExecutionResult): number => {
-    return callResult.nestedExecutions.reduce((counter, exec) => {
+    return callResult.nestedExecutionResults.reduce((counter, exec) => {
       const nestedCounter = collectFinalMinRevertibleSideEffectCounterRecursive(exec);
       return nestedCounter ? nestedCounter : counter;
     }, callResult.publicInputs.minRevertibleSideEffectCounter.toNumber());
@@ -310,6 +279,12 @@ export function collectNested<T>(
   const thisExecutionReads = executionStack.flatMap(extractExecutionItems);
 
   return thisExecutionReads.concat(
-    executionStack.flatMap(({ nestedExecutions }) => collectNested(nestedExecutions, extractExecutionItems)),
+    executionStack.flatMap(({ nestedExecutionResults }) =>
+      collectNested(nestedExecutionResults, extractExecutionItems),
+    ),
   );
 }
+
+export class PrivateExecutionProfileResult {
+  constructor(public timings: { witgen: number; oracles?: Record<string, { times: number[] }> }) {}
+}