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

package/src/tests/mocks.ts

@@ -11,7 +11,6 @@ import { SerializableContractInstance } from '../contract/contract_instance.js';
 import type { ContractInstanceWithAddress } from '../contract/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { GasSettings } from '../gas/gas_settings.js';
-import { computeVarArgsHash } from '../hash/hash.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import {
@@ -26,15 +25,7 @@ import { BlockProposal } from '../p2p/block_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import {
-  BlockHeader,
-  CallContext,
-  CountedPublicExecutionRequest,
-  PrivateCallExecutionResult,
-  PrivateExecutionResult,
-  PublicExecutionRequest,
-  Tx,
-} from '../tx/index.js';
+import { BlockHeader, HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, Tx } from '../tx/index.js';
 import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
@@ -77,70 +68,20 @@ export const randomUniqueNote = async ({
   );
 };
 
-export const mockPrivateCallExecutionResult = async (
-  seed = 1,
-  numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
-  numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
-  hasPublicTeardownCallRequest = false,
-) => {
-  const totalPublicCallRequests =
-    numberOfNonRevertiblePublicCallRequests +
-    numberOfRevertiblePublicCallRequests +
-    (hasPublicTeardownCallRequest ? 1 : 0);
-  const isForPublic = totalPublicCallRequests > 0;
-  let enqueuedPublicFunctionCalls: PublicExecutionRequest[] = [];
-  let publicTeardownFunctionCall = PublicExecutionRequest.empty();
-  if (isForPublic) {
-    const publicCallRequests = times(totalPublicCallRequests, i => makePublicCallRequest(seed + 0x102 + i)).reverse(); // Reverse it so that they are sorted by counters in descending order.
-    const publicFunctionArgs = times(totalPublicCallRequests, i => [new Fr(seed + i * 100), new Fr(seed + i * 101)]);
-    for (let i = 0; i < publicCallRequests.length; i++) {
-      const r = publicCallRequests[i];
-      r.argsHash = await computeVarArgsHash(publicFunctionArgs[i]);
-      i++;
-    }
-
-    if (hasPublicTeardownCallRequest) {
-      const request = publicCallRequests.shift()!;
-      const args = publicFunctionArgs.shift()!;
-      publicTeardownFunctionCall = new PublicExecutionRequest(CallContext.fromFields(request.toFields()), args);
-    }
-
-    enqueuedPublicFunctionCalls = publicCallRequests.map(
-      (r, i) => new PublicExecutionRequest(CallContext.fromFields(r.toFields()), publicFunctionArgs[i]),
-    );
-  }
-  return new PrivateCallExecutionResult(
-    Buffer.from(''),
-    Buffer.from(''),
-    new Map(),
-    PrivateCircuitPublicInputs.empty(),
-    new Map(),
-    [],
-    new Map(),
-    [],
-    [],
-    enqueuedPublicFunctionCalls.map((call, index) => new CountedPublicExecutionRequest(call, index)),
-    publicTeardownFunctionCall,
-    [],
-  );
-};
-
-export const mockPrivateExecutionResult = async (seed = 1) => {
-  return new PrivateExecutionResult(await mockPrivateCallExecutionResult(seed), Fr.zero());
-};
-
 export const mockTx = async (
   seed = 1,
   {
     numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
     numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
     hasPublicTeardownCallRequest = false,
+    publicCalldataSize = 2,
     feePayer,
     clientIvcProof = ClientIvcProof.empty(),
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
     hasPublicTeardownCallRequest?: boolean;
+    publicCalldataSize?: number;
     feePayer?: AztecAddress;
     clientIvcProof?: ClientIvcProof;
   } = {},
@@ -155,8 +96,7 @@ export const mockTx = async (
   data.constants.txContext.gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) });
   data.feePayer = feePayer ?? (await AztecAddress.random());
 
-  let enqueuedPublicFunctionCalls: PublicExecutionRequest[] = [];
-  let publicTeardownFunctionCall = PublicExecutionRequest.empty();
+  const publicFunctionCalldata: HashedValues[] = [];
   if (!isForPublic) {
     data.forRollup!.end.nullifiers[0] = firstNullifier.value;
   } else {
@@ -166,24 +106,18 @@ export const mockTx = async (
     const revertibleBuilder = new PrivateToPublicAccumulatedDataBuilder();
     const nonRevertibleBuilder = new PrivateToPublicAccumulatedDataBuilder();
 
-    const publicCallRequests = times(totalPublicCallRequests, i => makePublicCallRequest(seed + 0x102 + i)).reverse(); // Reverse it so that they are sorted by counters in descending order.
-    const publicFunctionArgs = times(totalPublicCallRequests, i => [new Fr(seed + i * 100), new Fr(seed + i * 101)]);
+    const publicCallRequests = times(totalPublicCallRequests, i => makePublicCallRequest(seed + 0x102 + i));
+    const calldata = times(totalPublicCallRequests, i => times(publicCalldataSize, j => new Fr(seed + (i * 13 + j))));
     for (let i = 0; i < publicCallRequests.length; i++) {
-      const r = publicCallRequests[i];
-      r.argsHash = await computeVarArgsHash(publicFunctionArgs[i]);
+      const hashedCalldata = await HashedValues.fromCalldata(calldata[i]);
+      publicFunctionCalldata.push(hashedCalldata);
+      publicCallRequests[i].calldataHash = hashedCalldata.hash;
     }
 
     if (hasPublicTeardownCallRequest) {
-      const request = publicCallRequests.shift()!;
-      data.forPublic.publicTeardownCallRequest = request;
-      const args = publicFunctionArgs.shift()!;
-      publicTeardownFunctionCall = new PublicExecutionRequest(CallContext.fromFields(request.toFields()), args);
+      data.forPublic.publicTeardownCallRequest = publicCallRequests.pop()!;
     }
 
-    enqueuedPublicFunctionCalls = publicCallRequests.map(
-      (r, i) => new PublicExecutionRequest(CallContext.fromFields(r.toFields()), publicFunctionArgs[i]),
-    );
-
     data.forPublic.nonRevertibleAccumulatedData = nonRevertibleBuilder
       .pushNullifier(firstNullifier.value)
       .withPublicCallRequests(publicCallRequests.slice(numberOfRevertiblePublicCallRequests))
@@ -194,16 +128,30 @@ export const mockTx = async (
       .build();
   }
 
-  const tx = new Tx(data, clientIvcProof, [], enqueuedPublicFunctionCalls, publicTeardownFunctionCall);
-
-  return tx;
+  return new Tx(data, clientIvcProof, [], publicFunctionCalldata);
 };
 
 export const mockTxForRollup = (seed = 1) =>
   mockTx(seed, { numberOfNonRevertiblePublicCallRequests: 0, numberOfRevertiblePublicCallRequests: 0 });
 
+const emptyPrivateCallExecutionResult = () =>
+  new PrivateCallExecutionResult(
+    Buffer.from(''),
+    Buffer.from(''),
+    new Map(),
+    PrivateCircuitPublicInputs.empty(),
+    new Map(),
+    [],
+    new Map(),
+    [],
+    [],
+    [],
+  );
+
+const emptyPrivateExecutionResult = () => new PrivateExecutionResult(emptyPrivateCallExecutionResult(), Fr.zero(), []);
+
 export const mockSimulatedTx = async (seed = 1) => {
-  const privateExecutionResult = await mockPrivateExecutionResult(seed);
+  const privateExecutionResult = emptyPrivateExecutionResult();
   const tx = await mockTx(seed);
   const output = new PublicSimulationOutput(
     undefined,

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

@@ -11,7 +11,7 @@ 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 './public_call_request_with_calldata.js';
 export * from './tx_hash.js';
 export * from './tx_receipt.js';
 export * from './tx.js';

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,20 @@ 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(),
+    ]);
   }
 
   /**
@@ -149,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`.
@@ -172,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);
@@ -190,8 +165,6 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.nestedExecutions,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
       fields.contractClassLogs,
     );
   }
@@ -207,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))],
     );
   }
@@ -257,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/proven_tx.ts

@@ -4,12 +4,7 @@ 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,
-  collectEnqueuedPublicFunctionCalls,
-  collectPublicTeardownFunctionCall,
-  collectSortedContractClassLogs,
-} from './private_execution_result.js';
+import { PrivateExecutionResult, collectSortedContractClassLogs } from './private_execution_result.js';
 import { Tx } from './tx.js';
 
 export class TxProvingResult {
@@ -21,15 +16,12 @@ export class TxProvingResult {
 
   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,
+      this.privateExecutionResult.publicFunctionCalldata,
     );
     return tx;
   }

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

@@ -10,8 +10,6 @@ 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';
@@ -29,15 +27,12 @@ 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;
   }