@aztec/stdlib 0.81.0 → 0.82.1-alpha-testnet.1

package/src/tx/private_execution_result.ts

@@ -12,7 +12,7 @@ import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
 import { ContractClassLog } 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 { HashedValues } from './hashed_values.js';
 
 /**
  * The contents of a new note.
@@ -67,36 +67,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 +81,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(): number {
+    return this.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
   }
 }
 
@@ -142,10 +130,6 @@ export class PrivateCallExecutionResult {
     public returnValues: 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,
     /**
      * Contract class logs emitted during execution of this function call.
      * Note: These are preimages to `contractClassLogsHashes`.
@@ -165,8 +149,6 @@ export class PrivateCallExecutionResult {
         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,
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
       .transform(PrivateCallExecutionResult.from);
@@ -183,8 +165,6 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.nestedExecutions,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
       fields.contractClassLogs,
     );
   }
@@ -200,8 +180,6 @@ export class PrivateCallExecutionResult {
       new Map([[0, 0]]),
       [Fr.random()],
       await timesParallel(nested, () => PrivateCallExecutionResult.random(0)),
-      [await CountedPublicExecutionRequest.random()],
-      await PublicExecutionRequest.random(),
       [new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))],
     );
   }
@@ -250,49 +228,6 @@ export function collectSortedContractClassLogs(execResult: PrivateExecutionResul
   return sortedLogs.map(l => l.log);
 }
 
-function collectEnqueuedCountedPublicExecutionRequests(
-  execResult: PrivateCallExecutionResult,
-): CountedPublicExecutionRequest[] {
-  return [
-    ...execResult.enqueuedPublicFunctionCalls,
-    ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests),
-  ];
-}
-
-/**
- * Collect all enqueued public function calls across all nested executions.
- * @param execResult - The topmost execution result.
- * @returns All enqueued public function calls.
- */
-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[] => {
-    return [
-      callResult.publicTeardownFunctionCall,
-      ...callResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCallRecursive),
-    ].filter(call => !call.isEmpty());
-  };
-  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();
-}
-
 export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {
   const collectFinalMinRevertibleSideEffectCounterRecursive = (callResult: PrivateCallExecutionResult): number => {
     return callResult.nestedExecutions.reduce((counter, exec) => {

package/src/tx/profiled_tx.ts

@@ -0,0 +1,27 @@
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+
+export class TxProfileResult {
+  constructor(public executionSteps: PrivateExecutionStep[]) {}
+
+  static get schema(): ZodFor<TxProfileResult> {
+    return z
+      .object({
+        executionSteps: z.array(PrivateExecutionStepSchema),
+      })
+      .transform(({ executionSteps }) => new TxProfileResult(executionSteps));
+  }
+
+  static random(): TxProfileResult {
+    return new TxProfileResult([
+      {
+        functionName: 'random',
+        bytecode: Buffer.from('random'),
+        witness: new Map([[1, 'random']]),
+      },
+    ]);
+  }
+}

package/src/tx/proven_tx.ts

@@ -0,0 +1,50 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { PrivateExecutionResult, collectSortedContractClassLogs } from './private_execution_result.js';
+import { Tx } from './tx.js';
+
+export class TxProvingResult {
+  constructor(
+    public privateExecutionResult: PrivateExecutionResult,
+    public publicInputs: PrivateKernelTailCircuitPublicInputs,
+    public clientIvcProof: ClientIvcProof,
+  ) {}
+
+  toTx(): Tx {
+    const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+
+    const tx = new Tx(
+      this.publicInputs,
+      this.clientIvcProof,
+      contractClassLogs,
+      this.privateExecutionResult.publicFunctionCalldata,
+    );
+    return tx;
+  }
+
+  static get schema() {
+    return z
+      .object({
+        privateExecutionResult: PrivateExecutionResult.schema,
+        publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+        clientIvcProof: ClientIvcProof.schema,
+      })
+      .transform(TxProvingResult.from);
+  }
+
+  static from(fields: FieldsOf<TxProvingResult>) {
+    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+  }
+
+  static async random() {
+    return new TxProvingResult(
+      await PrivateExecutionResult.random(),
+      PrivateKernelTailCircuitPublicInputs.empty(),
+      ClientIvcProof.empty(),
+    );
+  }
+}

package/src/tx/public_call_request_with_calldata.ts

@@ -0,0 +1,72 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { FunctionSelector } from '../abi/function_selector.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { type ZodFor, schemas } from '../schemas/index.js';
+import { Vector } from '../types/index.js';
+
+/**
+ * The call request of a public function, including the calldata.
+ */
+export class PublicCallRequestWithCalldata {
+  constructor(
+    /**
+     * Request of the public call.
+     */
+    public request: PublicCallRequest,
+    /**
+     * Function selector and arguments of the public call.
+     */
+    public calldata: Fr[],
+  ) {}
+
+  // Public functions get routed through the dispatch function, whose first argument is the target function selector.
+  get functionSelector(): FunctionSelector {
+    return FunctionSelector.fromField(this.calldata[0]);
+  }
+
+  get args(): Fr[] {
+    return this.calldata.slice(1);
+  }
+
+  static get schema(): ZodFor<PublicCallRequestWithCalldata> {
+    return z
+      .object({
+        request: PublicCallRequest.schema,
+        calldata: z.array(schemas.Fr),
+      })
+      .transform(PublicCallRequestWithCalldata.from);
+  }
+
+  static from(fields: Pick<PublicCallRequestWithCalldata, 'request' | 'calldata'>): PublicCallRequestWithCalldata {
+    return new PublicCallRequestWithCalldata(fields.request, fields.calldata);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.request, new Vector(this.calldata));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicCallRequestWithCalldata(PublicCallRequest.fromBuffer(reader), reader.readVector(Fr));
+  }
+
+  static empty() {
+    return new PublicCallRequestWithCalldata(PublicCallRequest.empty(), []);
+  }
+
+  isEmpty(): boolean {
+    return this.request.isEmpty() && this.calldata.length === 0;
+  }
+
+  [inspect.custom]() {
+    return `PublicCallRequestWithCalldata {
+      request: ${inspect(this.request)}
+      calldata: ${this.calldata}
+    }`;
+  }
+}

package/src/tx/simulated_tx.ts

@@ -5,17 +5,11 @@ import { z } from 'zod';
 
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
-import {
-  type PrivateKernelProverProfileResult,
-  PrivateKernelProverProfileResultSchema,
-} from '../kernel/private_kernel_prover_profile_result.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import {
   PrivateCallExecutionResult,
   PrivateExecutionResult,
-  collectEnqueuedPublicFunctionCalls,
-  collectPublicTeardownFunctionCall,
   collectSortedContractClassLogs,
 } from './private_execution_result.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
@@ -33,29 +27,23 @@ export class PrivateSimulationResult {
 
   toSimulatedTx(): Tx {
     const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
 
     const tx = new Tx(
       this.publicInputs,
       ClientIvcProof.empty(),
       contractClassLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
+      this.privateExecutionResult.publicFunctionCalldata,
     );
     return tx;
   }
 }
 
-export class TxSimulationResult extends PrivateSimulationResult {
+export class TxSimulationResult {
   constructor(
-    privateExecutionResult: PrivateExecutionResult,
-    publicInputs: PrivateKernelTailCircuitPublicInputs,
+    public privateExecutionResult: PrivateExecutionResult,
+    public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public publicOutput?: PublicSimulationOutput,
-    public profileResult?: PrivateKernelProverProfileResult,
-  ) {
-    super(privateExecutionResult, publicInputs);
-  }
+  ) {}
 
   get gasUsed(): GasUsed {
     return (
@@ -74,34 +62,22 @@ export class TxSimulationResult extends PrivateSimulationResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         publicOutput: PublicSimulationOutput.schema.optional(),
-        profileResult: PrivateKernelProverProfileResultSchema.optional(),
       })
       .transform(TxSimulationResult.from);
   }
 
   static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>) {
-    return new TxSimulationResult(
-      fields.privateExecutionResult,
-      fields.publicInputs,
-      fields.publicOutput,
-      fields.profileResult,
-    );
-  }
-
-  getPublicReturnValues() {
-    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
+    return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput);
   }
 
   static fromPrivateSimulationResultAndPublicOutput(
     privateSimulationResult: PrivateSimulationResult,
     publicOutput?: PublicSimulationOutput,
-    profileResult?: PrivateKernelProverProfileResult,
   ) {
     return new TxSimulationResult(
       privateSimulationResult.privateExecutionResult,
       privateSimulationResult.publicInputs,
       publicOutput,
-      profileResult,
     );
   }
 
@@ -112,50 +88,17 @@ export class TxSimulationResult extends PrivateSimulationResult {
       await PublicSimulationOutput.random(),
     );
   }
-}
-
-export class TxProvingResult {
-  constructor(
-    public privateExecutionResult: PrivateExecutionResult,
-    public publicInputs: PrivateKernelTailCircuitPublicInputs,
-    public clientIvcProof: ClientIvcProof,
-  ) {}
 
-  toTx(): Tx {
-    const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
-
-    const tx = new Tx(
-      this.publicInputs,
-      this.clientIvcProof,
-      contractClassLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-    return tx;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        privateExecutionResult: PrivateExecutionResult.schema,
-        publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
-      })
-      .transform(TxProvingResult.from);
+  getPrivateReturnValues() {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
   }
 
-  static from(fields: FieldsOf<TxProvingResult>) {
-    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+  toSimulatedTx(): Tx {
+    return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
   }
 
-  static async random() {
-    return new TxProvingResult(
-      await PrivateExecutionResult.random(),
-      PrivateKernelTailCircuitPublicInputs.empty(),
-      ClientIvcProof.empty(),
-    );
+  getPublicReturnValues() {
+    return this.publicOutput ? this.publicOutput.publicReturnValues : [];
   }
 }