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

package/src/kernel/public_call_request.ts

@@ -7,8 +7,8 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { inspect } from 'util';
 import { z } from 'zod';
 
-import { FunctionSelector } from '../abi/index.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { computeCalldataHash } from '../hash/index.js';
 import type { UInt32 } from '../types/shared.js';
 
 /**
@@ -24,15 +24,14 @@ export class PublicCallRequest {
      * The contract address being called.
      */
     public contractAddress: AztecAddress,
-    /**
-     * Function selector of the function being called.
-     */
-    public functionSelector: FunctionSelector,
     /**
      * Determines whether the call is modifying state.
      */
     public isStaticCall: boolean,
-    public argsHash: Fr,
+    /**
+     * Hash of the calldata of the function being called.
+     */
+    public calldataHash: Fr,
   ) {}
 
   static get schema() {
@@ -40,12 +39,11 @@ export class PublicCallRequest {
       .object({
         msgSender: AztecAddress.schema,
         contractAddress: AztecAddress.schema,
-        functionSelector: FunctionSelector.schema,
         isStaticCall: z.boolean(),
-        argsHash: schemas.Fr,
+        calldataHash: schemas.Fr,
       })
-      .transform(({ msgSender, contractAddress, functionSelector, isStaticCall, argsHash }) => {
-        return new PublicCallRequest(msgSender, contractAddress, functionSelector, isStaticCall, argsHash);
+      .transform(({ msgSender, contractAddress, isStaticCall, calldataHash }) => {
+        return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
       });
   }
 
@@ -58,13 +56,7 @@ export class PublicCallRequest {
   }
 
   static getFields(fields: FieldsOf<PublicCallRequest>) {
-    return [
-      fields.msgSender,
-      fields.contractAddress,
-      fields.functionSelector,
-      fields.isStaticCall,
-      fields.argsHash,
-    ] as const;
+    return [fields.msgSender, fields.contractAddress, fields.isStaticCall, fields.calldataHash] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): PublicCallRequest {
@@ -72,7 +64,6 @@ export class PublicCallRequest {
     return new PublicCallRequest(
       reader.readObject(AztecAddress),
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionSelector),
       reader.readBoolean(),
       reader.readField(),
     );
@@ -93,7 +84,6 @@ export class PublicCallRequest {
     return new PublicCallRequest(
       reader.readObject(AztecAddress),
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionSelector),
       reader.readBoolean(),
       reader.readObject(Fr),
     );
@@ -104,16 +94,12 @@ export class PublicCallRequest {
   }
 
   static empty() {
-    return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, FunctionSelector.empty(), false, Fr.ZERO);
+    return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, false, Fr.ZERO);
   }
 
   isEmpty(): boolean {
     return (
-      this.msgSender.isZero() &&
-      this.contractAddress.isZero() &&
-      this.functionSelector.isEmpty() &&
-      !this.isStaticCall &&
-      this.argsHash.isEmpty()
+      this.msgSender.isZero() && this.contractAddress.isZero() && !this.isStaticCall && this.calldataHash.isEmpty()
     );
   }
 
@@ -121,11 +107,20 @@ export class PublicCallRequest {
     return `PublicCallRequest {
       msgSender: ${this.msgSender}
       contractAddress: ${this.contractAddress}
-      functionSelector: ${this.functionSelector}
       isStaticCall: ${this.isStaticCall}
-      argsHash: ${this.argsHash}
+      calldataHash: ${this.calldataHash}
     }`;
   }
+
+  static async fromCalldata(
+    msgSender: AztecAddress,
+    contractAddress: AztecAddress,
+    isStaticCall: boolean,
+    calldata: Fr[],
+  ) {
+    const calldataHash = await computeCalldataHash(calldata);
+    return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
+  }
 }
 
 export class CountedPublicCallRequest {

package/src/logs/log_with_tx_data.ts

@@ -1,8 +1,8 @@
 import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 
-// TypeScript representation of the Noir aztec::oracle::note_discovery::LogWithTxData struct. This is used as a response
-// for PXE's custom getLogByTag oracle.
+// TypeScript representation of the Noir aztec::oracle::message_discovery::LogWithTxData struct. This is used as a
+// response for PXE's custom getLogByTag oracle.
 export class LogWithTxData {
   constructor(
     public logContent: Fr[],

package/src/noir/index.ts

@@ -75,7 +75,7 @@ export interface NoirCompiledContract {
 }
 
 /**
- * The compilation result of an Aztec.nr contract.
+ * The compilation result of a protocol (non-contract) circuit.
  */
 export interface NoirCompiledCircuit {
   /** The hash of the circuit. */
@@ -92,6 +92,11 @@ export interface NoirCompiledCircuit {
   file_map: DebugFileMap;
 }
 
+export interface NoirCompiledCircuitWithName extends NoirCompiledCircuit {
+  /** The name of the circuit. */
+  name: string;
+}
+
 /**
  * The debug metadata of an Aztec.nr contract.
  */

package/src/proofs/client_ivc_proof.ts

@@ -3,7 +3,6 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 const CLIENT_IVC_PROOF_LENGTH = 172052;
-const CLIENT_IVC_VK_LENGTH = 2730;
 
 /**
  * TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370) refactor this to
@@ -15,7 +14,6 @@ export class ClientIvcProof {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7370): Need to precompute private kernel tail VK so we can verify this immediately in the tx pool
     // which parts of these are needed to quickly verify that we have a correct IVC proof
     public clientIvcProofBuffer: Buffer,
-    public clientIvcVkBuffer: Buffer,
   ) {}
 
   public isEmpty() {
@@ -23,18 +21,15 @@ export class ClientIvcProof {
   }
 
   static empty() {
-    return new ClientIvcProof(Buffer.from(''), Buffer.from(''));
+    return new ClientIvcProof(Buffer.from(''));
   }
 
   static fake(fill = Math.floor(Math.random() * 255)) {
-    return new ClientIvcProof(Buffer.alloc(1, fill), Buffer.alloc(1, fill));
+    return new ClientIvcProof(Buffer.alloc(1, fill));
   }
 
   static random() {
-    return new ClientIvcProof(
-      Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)),
-      Buffer.from(randomBytes(CLIENT_IVC_VK_LENGTH)),
-    );
+    return new ClientIvcProof(Buffer.from(randomBytes(CLIENT_IVC_PROOF_LENGTH)));
   }
 
   static get schema() {
@@ -47,15 +42,10 @@ export class ClientIvcProof {
 
   static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
     const reader = BufferReader.asReader(buffer);
-    return new ClientIvcProof(reader.readBuffer(), reader.readBuffer());
+    return new ClientIvcProof(reader.readBuffer());
   }
 
   public toBuffer() {
-    return serializeToBuffer(
-      this.clientIvcProofBuffer.length,
-      this.clientIvcProofBuffer,
-      this.clientIvcVkBuffer.length,
-      this.clientIvcVkBuffer,
-    );
+    return serializeToBuffer(this.clientIvcProofBuffer.length, this.clientIvcProofBuffer);
   }
 }

package/src/rollup/tube_inputs.ts

@@ -5,15 +5,19 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 
+/**
+ * Inputs for the tube circuit, which turns a client IVC proof folding stack into an ultrahonk proof.
+ * 'usePublicTailVk' signifies if we should prove this with the public or private kernel tail client IVC VKs.
+ */
 export class TubeInputs {
-  constructor(public clientIVCData: ClientIvcProof) {}
+  constructor(public usePublicTailVk: boolean, public clientIVCData: ClientIvcProof) {}
 
   static from(fields: FieldsOf<TubeInputs>): TubeInputs {
     return new TubeInputs(...TubeInputs.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<TubeInputs>) {
-    return [fields.clientIVCData] as const;
+    return [fields.usePublicTailVk, fields.clientIVCData] as const;
   }
 
   /**
@@ -39,7 +43,7 @@ export class TubeInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): TubeInputs {
     const reader = BufferReader.asReader(buffer);
-    return new TubeInputs(reader.readObject(ClientIvcProof));
+    return new TubeInputs(reader.readBoolean(), reader.readObject(ClientIvcProof));
   }
 
   isEmpty(): boolean {
@@ -55,7 +59,7 @@ export class TubeInputs {
   }
 
   static empty() {
-    return new TubeInputs(ClientIvcProof.empty());
+    return new TubeInputs(false, ClientIvcProof.empty());
   }
 
   /** Returns a hex representation for JSON serialization. */

package/src/stats/stats.ts

@@ -225,7 +225,7 @@ export type TxStats = {
   /** Serialized size of contract class logs in fields. */
   contractClassLogSize: number;
   /** How this tx pays for its fee */
-  feePaymentMethod: 'fee_juice' | 'fpc_public' | 'fpc_private';
+  feePaymentMethod: 'fee_juice' | 'fpc';
 };
 
 /**

package/src/tests/factories.ts

@@ -78,7 +78,6 @@ import {
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
-  type PublicFunction,
   SerializableContractInstance,
   type UnconstrainedFunctionWithMembershipProof,
   computeContractClassId,
@@ -523,13 +522,7 @@ function makePrivateCallRequest(seed = 1): PrivateCallRequest {
 }
 
 export function makePublicCallRequest(seed = 1) {
-  return new PublicCallRequest(
-    makeAztecAddress(seed),
-    makeAztecAddress(seed + 1),
-    makeSelector(seed + 2),
-    false,
-    fr(seed + 0x3),
-  );
+  return new PublicCallRequest(makeAztecAddress(seed), makeAztecAddress(seed + 1), false, fr(seed + 0x3));
 }
 
 function makeCountedPublicCallRequest(seed = 1) {
@@ -1171,16 +1164,10 @@ export function makeUnconstrainedFunctionWithMembershipProof(seed = 0): Unconstr
   };
 }
 
-export async function makeContractClassPublic(
-  seed = 0,
-  publicDispatchFunction?: PublicFunction,
-): Promise<ContractClassPublic> {
+export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer): Promise<ContractClassPublic> {
   const artifactHash = fr(seed + 1);
-  const publicFunctions = publicDispatchFunction
-    ? [publicDispatchFunction]
-    : makeTuple(1, makeContractClassPublicFunction, seed + 2);
   const privateFunctionsRoot = fr(seed + 3);
-  const packedBytecode = publicDispatchFunction?.bytecode ?? makeBytes(100, seed + 4);
+  const packedBytecode = publicBytecode ?? makeBytes(100, seed + 4);
   const publicBytecodeCommitment = await computePublicBytecodeCommitment(packedBytecode);
   const id = await computeContractClassId({ artifactHash, privateFunctionsRoot, publicBytecodeCommitment });
   return {
@@ -1188,20 +1175,12 @@ export async function makeContractClassPublic(
     artifactHash,
     packedBytecode,
     privateFunctionsRoot,
-    publicFunctions,
     privateFunctions: [],
     unconstrainedFunctions: [],
     version: 1,
   };
 }
 
-function makeContractClassPublicFunction(seed = 0): PublicFunction {
-  return {
-    selector: FunctionSelector.fromField(fr(seed + 1)),
-    bytecode: makeBytes(100, seed + 2),
-  };
-}
-
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function makeContractClassPrivateFunction(seed = 0): PrivateFunction {
   return {

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/trees/nullifier_membership_witness.ts

@@ -56,4 +56,16 @@ export class NullifierMembershipWitness {
   public toFields(): Fr[] {
     return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
   }
+
+  /**
+   * Returns a representation of the nullifier membership witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      ...(this.leafPreimage.toFields().map(fr => fr.toString()) as string[]),
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
 }

package/src/trees/public_data_witness.ts

@@ -58,6 +58,21 @@ export class PublicDataWitness {
     ];
   }
 
+  /**
+   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.index).toString() as string,
+      new Fr(this.leafPreimage.slot).toString() as string,
+      new Fr(this.leafPreimage.value).toString() as string,
+      new Fr(this.leafPreimage.nextSlot).toString() as string,
+      new Fr(this.leafPreimage.nextIndex).toString() as string,
+      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
+    ];
+  }
+
   toBuffer(): Buffer {
     return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
   }

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,11 +11,13 @@ 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';
 export * from './processed_tx.js';
+export * from './proven_tx.js';
+export * from './profiled_tx.js';
 export * from './simulated_tx.js';
 export * from './tx_effect.js';
 export * from './public_simulation_output.js';