@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/tx/private_execution_result.ts

@@ -9,10 +9,13 @@ 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 { type PreTag, PreTagSchema } from '../logs/pre_tag.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 +50,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 +73,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 +87,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 anchor block number that this execution was simulated with.
+   */
+  getSimulationAnchorBlockNumber(): UInt32 {
+    return this.entrypoint.publicInputs.anchorBlockHeader.globalVariables.blockNumber;
   }
 }
 
@@ -140,17 +134,19 @@ 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 pre tags used in this tx to compute tags for private logs */
+    public preTags: PreTag[],
     /** 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 +160,9 @@ 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) })),
+        preTags: z.array(PreTagSchema),
+        nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
       .transform(PrivateCallExecutionResult.from);
@@ -182,9 +178,9 @@ export class PrivateCallExecutionResult {
       fields.newNotes,
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
-      fields.nestedExecutions,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
+      fields.offchainEffects,
+      fields.preTags,
+      fields.nestedExecutionResults,
       fields.contractClassLogs,
     );
   }
@@ -199,9 +195,13 @@ 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 +211,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 +224,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 +236,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 +244,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 +285,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[] }> }) {}
+}

package/src/tx/private_tx_constant_data.ts

@@ -0,0 +1,94 @@
+import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { BlockHeader } from './block_header.js';
+import { ProtocolContracts } from './protocol_contracts.js';
+import { TxContext } from './tx_context.js';
+
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */
+export class PrivateTxConstantData {
+  constructor(
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    public anchorBlockHeader: BlockHeader,
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.anchor_block_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * List of protocol contracts.
+     */
+    public protocolContracts: ProtocolContracts,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateTxConstantData>) {
+    return new PrivateTxConstantData(...PrivateTxConstantData.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateTxConstantData>) {
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContracts] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PrivateTxConstantData {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PrivateTxConstantData.getFields(this));
+    if (fields.length !== TX_CONSTANT_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PrivateTxConstantData. Expected ${TX_CONSTANT_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateTxConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PrivateTxConstantData.getFields(this));
+  }
+
+  static empty() {
+    return new PrivateTxConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, ProtocolContracts.empty());
+  }
+
+  getSize() {
+    return (
+      this.anchorBlockHeader.getSize() +
+      this.txContext.getSize() +
+      this.vkTreeRoot.size +
+      this.protocolContracts.getSize()
+    );
+  }
+
+  clone(): PrivateTxConstantData {
+    return PrivateTxConstantData.fromBuffer(this.toBuffer());
+  }
+}

package/src/tx/processed_tx.ts

@@ -6,10 +6,9 @@ import { RevertCode } from '../avm/revert_code.js';
 import type { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import { siloL2ToL1Message } from '../hash/hash.js';
-import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import { computeL2ToL1MessageHash } from '../hash/hash.js';
 import type { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProof } from '../proofs/chonk_proof.js';
 import type { GlobalVariables } from './global_variables.js';
 import type { Tx } from './tx.js';
 import { TxEffect } from './tx_effect.js';
@@ -37,15 +36,15 @@ export type ProcessedTx = {
   /**
    * Proof for the private execution.
    */
-  clientIvcProof: ClientIvcProof;
+  chonkProof: ChonkProof;
   /**
    * The request for AVM proving.
    */
   avmProvingRequest: AvmProvingRequest | undefined;
   /**
-   * Combining `TxConstantData` specified by the user, and `GlobalVariables` injected by the sequencer.
+   * `GlobalVariables` injected by the sequencer. It's the same for all the txs in a block.
    */
-  constants: CombinedConstantData;
+  globalVariables: GlobalVariables;
   /**
    * Output data of the tx.
    */
@@ -78,28 +77,34 @@ export type FailedTx = {
   error: Error;
 };
 
-export async function makeProcessedTxFromPrivateOnlyTx(
+export function makeProcessedTxFromPrivateOnlyTx(
   tx: Tx,
   transactionFee: Fr,
   feePaymentPublicDataWrite: PublicDataWrite,
   globalVariables: GlobalVariables,
-): Promise<ProcessedTx> {
-  const constants = CombinedConstantData.combine(tx.data.constants, globalVariables);
-
+): ProcessedTx {
   const data = tx.data.forRollup!;
   const txEffect = new TxEffect(
     RevertCode.OK,
-    await tx.getTxHash(),
+    tx.getTxHash(),
     transactionFee,
     data.end.noteHashes.filter(h => !h.isZero()),
     data.end.nullifiers.filter(h => !h.isZero()),
     data.end.l2ToL1Msgs
-      .map(message => siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId))
-      .filter(h => !h.isZero()),
+      .filter(msg => !msg.contractAddress.isZero())
+      .map(msg =>
+        computeL2ToL1MessageHash({
+          l2Sender: msg.contractAddress,
+          l1Recipient: msg.message.recipient,
+          content: msg.message.content,
+          rollupVersion: globalVariables.version,
+          chainId: globalVariables.chainId,
+        }),
+      ),
     [feePaymentPublicDataWrite],
     data.end.privateLogs.filter(l => !l.isEmpty()),
     [],
-    await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true),
+    tx.getContractClassLogs(),
   );
 
   const gasUsed = {
@@ -113,9 +118,9 @@ export async function makeProcessedTxFromPrivateOnlyTx(
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest: undefined,
-    constants,
+    globalVariables,
     txEffect,
     gasUsed,
     revertCode: RevertCode.OK,
@@ -123,22 +128,16 @@ export async function makeProcessedTxFromPrivateOnlyTx(
   };
 }
 
-export function toNumBlobFields(txs: ProcessedTx[]): number {
-  return txs.reduce((acc, tx) => {
-    return acc + tx.txEffect.toBlobFields().length;
-  }, 0);
-}
-
-export async function makeProcessedTxFromTxWithPublicCalls(
+export function makeProcessedTxFromTxWithPublicCalls(
   tx: Tx,
   avmProvingRequest: AvmProvingRequest,
   gasUsed: GasUsed,
   revertCode: RevertCode,
   revertReason: SimulationError | undefined,
-): Promise<ProcessedTx> {
+): ProcessedTx {
   const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
 
-  const constants = CombinedConstantData.combine(tx.data.constants, avmPublicInputs.globalVariables);
+  const globalVariables = avmPublicInputs.globalVariables;
 
   const publicDataWrites = avmPublicInputs.accumulatedData.publicDataWrites.filter(w => !w.isEmpty());
 
@@ -147,32 +146,39 @@ export async function makeProcessedTxFromTxWithPublicCalls(
     ...(revertCode.isOK() ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs : []),
   ].filter(l => !l.isEmpty());
 
-  const contractClassLogs = [
-    ...(await tx.getSplitContractClassLogs(false, true)),
-    ...(revertCode.isOK() ? await tx.getSplitContractClassLogs(true, true) : []),
-  ].filter(l => !l.isEmpty());
+  const contractClassLogs = revertCode.isOK()
+    ? tx.getContractClassLogs()
+    : tx.getSplitContractClassLogs(false /* revertible */);
 
   const txEffect = new TxEffect(
     revertCode,
-    await tx.getTxHash(),
+    tx.getTxHash(),
     avmPublicInputs.transactionFee,
     avmPublicInputs.accumulatedData.noteHashes.filter(h => !h.isZero()),
     avmPublicInputs.accumulatedData.nullifiers.filter(h => !h.isZero()),
     avmPublicInputs.accumulatedData.l2ToL1Msgs
-      .map(message => siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId))
-      .filter(h => !h.isZero()),
+      .filter(msg => !msg.contractAddress.isZero())
+      .map(msg =>
+        computeL2ToL1MessageHash({
+          l2Sender: msg.contractAddress,
+          l1Recipient: msg.message.recipient,
+          content: msg.message.content,
+          rollupVersion: globalVariables.version,
+          chainId: globalVariables.chainId,
+        }),
+      ),
     publicDataWrites,
     privateLogs,
-    avmPublicInputs.accumulatedData.publicLogs.filter(l => !l.isEmpty()),
+    avmPublicInputs.accumulatedData.publicLogs.toLogs(),
     contractClassLogs,
   );
 
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest,
-    constants,
+    globalVariables,
     txEffect,
     gasUsed,
     revertCode,