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

package/dest/tx/tx.js

@@ -8,7 +8,8 @@ import { ContractClassLog } from '../logs/contract_class_log.js';
 import { Gossipable } from '../p2p/gossipable.js';
 import { TopicType, createTopicString } from '../p2p/topic_type.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import { PublicExecutionRequest } from './public_execution_request.js';
+import { HashedValues } from './hashed_values.js';
+import { PublicCallRequestWithCalldata } from './public_call_request_with_calldata.js';
 import { TxHash } from './tx_hash.js';
 /**
  * The interface of an L2 transaction.
@@ -16,25 +17,22 @@ import { TxHash } from './tx_hash.js';
     data;
     clientIvcProof;
     contractClassLogs;
-    enqueuedPublicFunctionCalls;
-    publicTeardownFunctionCall;
+    publicFunctionCalldata;
     static p2pTopic;
     // For memoization
     txHash;
+    calldataMap;
     constructor(/**
      * Output of the private kernel circuit for this tx.
      */ data, /**
      * Proof from the private kernel circuit.
      * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
-     *
      */ clientIvcProof, /**
      * Contract class logs generated by the tx.
      */ contractClassLogs, /**
-     * Enqueued public functions from the private circuit to be run by the sequencer.
-     */ enqueuedPublicFunctionCalls, /**
-     * Public function call to be run by the sequencer as part of teardown.
-     */ publicTeardownFunctionCall){
-        super(), this.data = data, this.clientIvcProof = clientIvcProof, this.contractClassLogs = contractClassLogs, this.enqueuedPublicFunctionCalls = enqueuedPublicFunctionCalls, this.publicTeardownFunctionCall = publicTeardownFunctionCall;
+     * An array of calldata for the enqueued public function calls and the teardown function call.
+     */ publicFunctionCalldata){
+        super(), this.data = data, this.clientIvcProof = clientIvcProof, this.contractClassLogs = contractClassLogs, this.publicFunctionCalldata = publicFunctionCalldata;
     }
     // Gossipable method
     static{
@@ -45,25 +43,34 @@ import { TxHash } from './tx_hash.js';
         return new Buffer32((await this.getTxHash()).toBuffer());
     }
     hasPublicCalls() {
-        return this.data.numberOfPublicCallRequests() > 0;
+        return this.numberOfPublicCalls() > 0;
     }
-    getNonRevertiblePublicExecutionRequests() {
-        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-        return this.enqueuedPublicFunctionCalls.slice(numRevertible);
+    numberOfPublicCalls() {
+        return this.data.numberOfPublicCallRequests();
     }
-    getRevertiblePublicExecutionRequests() {
-        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-        return this.enqueuedPublicFunctionCalls.slice(0, numRevertible);
+    getNonRevertiblePublicCallRequestsWithCalldata() {
+        return this.data.getNonRevertiblePublicCallRequests().map((r)=>this.#combinePublicCallRequestWithCallData(r));
     }
-    getPublicTeardownExecutionRequest() {
-        return this.publicTeardownFunctionCall.isEmpty() ? undefined : this.publicTeardownFunctionCall;
+    getRevertiblePublicCallRequestsWithCalldata() {
+        return this.data.getRevertiblePublicCallRequests().map((r)=>this.#combinePublicCallRequestWithCallData(r));
     }
-    getTotalPublicArgsCount() {
-        let count = this.enqueuedPublicFunctionCalls.reduce((acc, execRequest)=>acc + execRequest.args.length, 0);
-        if (!this.publicTeardownFunctionCall.isEmpty()) {
-            count += this.publicTeardownFunctionCall.args.length;
-        }
-        return count;
+    getTeardownPublicCallRequestWithCalldata() {
+        const request = this.data.getTeardownPublicCallRequest();
+        return request ? this.#combinePublicCallRequestWithCallData(request) : undefined;
+    }
+    getPublicCallRequestsWithCalldata() {
+        const teardown = this.data.getTeardownPublicCallRequest();
+        const callRequests = [
+            ...this.data.getNonRevertiblePublicCallRequests(),
+            ...this.data.getRevertiblePublicCallRequests(),
+            ...teardown ? [
+                teardown
+            ] : []
+        ];
+        return callRequests.map((r)=>this.#combinePublicCallRequestWithCallData(r));
+    }
+    getTotalPublicCalldataCount() {
+        return this.publicFunctionCalldata.reduce((accum, cd)=>accum + cd.values.length, 0);
     }
     getGasSettings() {
         return this.data.constants.txContext.gasSettings;
@@ -74,10 +81,7 @@ import { TxHash } from './tx_hash.js';
    * @returns An instance of Tx.
    */ static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new Tx(reader.readObject(PrivateKernelTailCircuitPublicInputs), reader.readObject(ClientIvcProof), reader.readVectorUint8Prefix(ContractClassLog), reader.readVectorUint8Prefix(PublicExecutionRequest), reader.readObject(PublicExecutionRequest));
-    }
-    static newWithTxData(data, publicTeardownExecutionRequest) {
-        return new Tx(data, ClientIvcProof.empty(), [], [], publicTeardownExecutionRequest ? publicTeardownExecutionRequest : PublicExecutionRequest.empty());
+        return new Tx(reader.readObject(PrivateKernelTailCircuitPublicInputs), reader.readObject(ClientIvcProof), reader.readVectorUint8Prefix(ContractClassLog), reader.readVectorUint8Prefix(HashedValues));
     }
     /**
    * Serializes the Tx object into a Buffer.
@@ -87,8 +91,7 @@ import { TxHash } from './tx_hash.js';
             this.data,
             this.clientIvcProof,
             serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
-            serializeArrayOfBufferableToVector(this.enqueuedPublicFunctionCalls, 1),
-            this.publicTeardownFunctionCall
+            serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1)
         ]);
     }
     static get schema() {
@@ -96,12 +99,11 @@ import { TxHash } from './tx_hash.js';
             data: PrivateKernelTailCircuitPublicInputs.schema,
             clientIvcProof: ClientIvcProof.schema,
             contractClassLogs: z.array(ContractClassLog.schema),
-            enqueuedPublicFunctionCalls: z.array(PublicExecutionRequest.schema),
-            publicTeardownFunctionCall: PublicExecutionRequest.schema
+            publicFunctionCalldata: z.array(HashedValues.schema)
         }).transform(Tx.from);
     }
     static from(fields) {
-        return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogs, fields.enqueuedPublicFunctionCalls, fields.publicTeardownFunctionCall);
+        return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogs, fields.publicFunctionCalldata);
     }
     /**
    * Gets public logs emitted by this tx.
@@ -158,6 +160,14 @@ import { TxHash } from './tx_hash.js';
    */ setTxHash(hash) {
         this.txHash = hash;
     }
+    getCalldataMap() {
+        if (!this.calldataMap) {
+            const calldataMap = new Map();
+            this.publicFunctionCalldata.forEach((cd)=>calldataMap.set(cd.hash.toString(), cd.values));
+            this.calldataMap = calldataMap;
+        }
+        return this.calldataMap;
+    }
     /** Returns stats about this tx. */ async getStats() {
         return {
             txHash: (await this.getTxHash()).toString(),
@@ -169,13 +179,11 @@ import { TxHash } from './tx_hash.js';
             proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
             size: this.toBuffer().length,
             feePaymentMethod: // needsSetup? then we pay through a fee payment contract
-            this.data.forPublic?.needsSetup ? this.data.getNonRevertiblePublicCallRequests().at(-1).functionSelector.toField().toBigInt() === 0x43417bb1n ? 'fpc_public' : 'fpc_private' : 'fee_juice'
+            this.data.forPublic?.needsSetup ? 'fpc' : 'fee_juice'
         };
     }
     getSize() {
-        return this.data.getSize() + this.clientIvcProof.clientIvcProofBuffer.length + arraySerializedSizeOfNonEmpty(this.contractClassLogs) + arraySerializedSizeOfNonEmpty(this.enqueuedPublicFunctionCalls) + arraySerializedSizeOfNonEmpty([
-            this.publicTeardownFunctionCall
-        ]);
+        return this.data.getSize() + this.clientIvcProof.clientIvcProofBuffer.length + arraySerializedSizeOfNonEmpty(this.contractClassLogs) + this.publicFunctionCalldata.reduce((accum, cd)=>accum + cd.getSize(), 0);
     }
     /**
    * Estimates the tx size based on its private effects. Note that the actual size of the tx
@@ -205,9 +213,8 @@ import { TxHash } from './tx_hash.js';
         const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.toBuffer());
         const clientIvcProof = ClientIvcProof.fromBuffer(tx.clientIvcProof.toBuffer());
         const contractClassLogs = tx.contractClassLogs.map((x)=>ContractClassLog.fromBuffer(x.toBuffer()));
-        const enqueuedPublicFunctionCalls = tx.enqueuedPublicFunctionCalls.map((x)=>PublicExecutionRequest.fromBuffer(x.toBuffer()));
-        const publicTeardownFunctionCall = PublicExecutionRequest.fromBuffer(tx.publicTeardownFunctionCall.toBuffer());
-        const clonedTx = new Tx(publicInputs, clientIvcProof, contractClassLogs, enqueuedPublicFunctionCalls, publicTeardownFunctionCall);
+        const publicFunctionCalldata = tx.publicFunctionCalldata.map((cd)=>HashedValues.fromBuffer(cd.toBuffer()));
+        const clonedTx = new Tx(publicInputs, clientIvcProof, contractClassLogs, publicFunctionCalldata);
         if (tx.txHash) {
             clonedTx.setTxHash(TxHash.fromBuffer(tx.txHash.toBuffer()));
         }
@@ -221,8 +228,8 @@ import { TxHash } from './tx_hash.js';
         return new Tx(PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(), randomProof ? ClientIvcProof.random() : ClientIvcProof.empty(), [
             await ContractClassLog.random()
         ], [
-            await PublicExecutionRequest.random()
-        ], await PublicExecutionRequest.random());
+            HashedValues.random()
+        ]);
     }
     /**
    * Filters out logs from functions that are not present in the provided kernel output.
@@ -240,6 +247,13 @@ import { TxHash } from './tx_hash.js';
    */ async filterRevertedLogs() {
         this.contractClassLogs = await this.getSplitContractClassLogs(false);
     }
+    #combinePublicCallRequestWithCallData(request) {
+        const calldataMap = this.getCalldataMap();
+        // Assume empty calldata if nothing is given for the hash.
+        // The verification of calldata vs hash should be handled outside of this class.
+        const calldata = calldataMap.get(request.calldataHash.toString()) ?? [];
+        return new PublicCallRequestWithCalldata(request, calldata);
+    }
 }
 function hasHash(tx) {
     return tx.hash !== undefined;

package/dest/tx/tx_execution_request.js

@@ -108,7 +108,7 @@ import { TxRequest } from './tx_request.js';
     }
     static async random() {
         return new TxExecutionRequest(await AztecAddress.random(), FunctionSelector.random(), Fr.random(), TxContext.empty(), [
-            await HashedValues.random()
+            HashedValues.random()
         ], [
             AuthWitness.random()
         ], [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "0.82.0",
+  "version": "0.82.1-alpha-testnet.1",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -65,11 +65,11 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.82.0",
-    "@aztec/blob-lib": "0.82.0",
-    "@aztec/constants": "0.82.0",
-    "@aztec/ethereum": "0.82.0",
-    "@aztec/foundation": "0.82.0",
+    "@aztec/bb.js": "0.82.1-alpha-testnet.1",
+    "@aztec/blob-lib": "0.82.1-alpha-testnet.1",
+    "@aztec/constants": "0.82.1-alpha-testnet.1",
+    "@aztec/ethereum": "0.82.1-alpha-testnet.1",
+    "@aztec/foundation": "0.82.1-alpha-testnet.1",
     "lodash.chunk": "^4.2.0",
     "lodash.isequal": "^4.5.0",
     "lodash.omit": "^4.5.0",

package/src/contract/contract_class.ts

@@ -1,4 +1,3 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -6,7 +5,7 @@ import { type ContractArtifact, type FunctionArtifact, FunctionSelector, Functio
 import { hashVK } from '../hash/hash.js';
 import { computeArtifactHash } from './artifact_hash.js';
 import { type ContractClassIdPreimage, computeContractClassIdWithPreimage } from './contract_class_id.js';
-import type { ContractClass, ContractClassWithId, PublicFunction } from './interfaces/index.js';
+import type { ContractClass, ContractClassWithId } from './interfaces/index.js';
 
 /** Contract artifact including its artifact hash */
 type ContractArtifactWithHash = ContractArtifact & { artifactHash: Fr };
@@ -19,32 +18,16 @@ export async function getContractClassFromArtifact(
   artifact: ContractArtifact | ContractArtifactWithHash,
 ): Promise<ContractClassWithId & ContractClassIdPreimage> {
   const artifactHash = 'artifactHash' in artifact ? artifact.artifactHash : await computeArtifactHash(artifact);
-  const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
-  // TODO(#8985): ContractArtifact.functions should ensure that the below only contains the public dispatch function
-  // So we can likely remove this and just use the below to assign the dispatch.
-  const artifactPublicFunctions: ContractClass['publicFunctions'] = await Promise.all(
-    publicFunctions.map(async f => ({
-      selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
-      bytecode: f.bytecode,
-    })),
-  );
-
-  artifactPublicFunctions.sort(cmpFunctionArtifacts);
 
-  let packedBytecode = Buffer.alloc(0);
-  let dispatchFunction: PublicFunction | undefined = undefined;
-  if (artifactPublicFunctions.length > 0) {
-    dispatchFunction = artifactPublicFunctions.find(f =>
-      f.selector.equals(FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR))),
+  const publicFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PUBLIC);
+  if (publicFunctions.length > 1) {
+    throw new Error(
+      `Contract should contain at most one public function artifact. Received ${publicFunctions.length}.`,
     );
-    if (!dispatchFunction) {
-      throw new Error(
-        `A contract with public functions should define a public_dispatch(Field) function as its public entrypoint. Contract: ${artifact.name}`,
-      );
-    }
-    packedBytecode = dispatchFunction.bytecode;
   }
 
+  const packedBytecode = publicFunctions[0]?.bytecode ?? Buffer.alloc(0);
+
   const privateFunctions = artifact.functions.filter(f => f.functionType === FunctionType.PRIVATE);
   const privateArtifactFunctions: ContractClass['privateFunctions'] = await Promise.all(
     privateFunctions.map(getContractClassPrivateFunctionFromArtifact),
@@ -55,8 +38,6 @@ export async function getContractClassFromArtifact(
   const contractClass: ContractClass = {
     version: 1,
     artifactHash,
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
-    publicFunctions: dispatchFunction ? [dispatchFunction] : [],
     packedBytecode,
     privateFunctions: privateArtifactFunctions,
   };

package/src/contract/interfaces/contract_class.ts

@@ -19,9 +19,6 @@ export interface ContractClass {
   artifactHash: Fr;
   /** List of individual private functions, constructors included. */
   privateFunctions: PrivateFunction[];
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Remove public functions.
-  /** Contains the public_dispatch function (and only that) if there's any public code in the contract. */
-  publicFunctions: PublicFunction[];
   /** Bytecode for the public_dispatch function, or empty. */
   packedBytecode: Buffer;
 }
@@ -49,19 +46,6 @@ const ExecutablePrivateFunctionSchema = PrivateFunctionSchema.and(
   z.object({ bytecode: schemas.Buffer }),
 ) satisfies ZodFor<ExecutablePrivateFunction>;
 
-/** Public function definition within a contract class. */
-export interface PublicFunction {
-  /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
-  selector: FunctionSelector;
-  /** Public bytecode. */
-  bytecode: Buffer;
-}
-
-export const PublicFunctionSchema = z.object({
-  selector: FunctionSelector.schema,
-  bytecode: schemas.Buffer,
-}) satisfies ZodFor<PublicFunction>;
-
 /** Unconstrained function definition. */
 export interface UnconstrainedFunction {
   /** Selector of the function. Calculated as the hash of the method name and parameters. The specification of this is not enforced by the protocol. */
@@ -124,7 +108,6 @@ export const ContractClassSchema = z.object({
   version: z.literal(VERSION),
   artifactHash: schemas.Fr,
   privateFunctions: z.array(PrivateFunctionSchema),
-  publicFunctions: z.array(PublicFunctionSchema),
   packedBytecode: schemas.Buffer,
 }) satisfies ZodFor<ContractClass>;
 
@@ -151,7 +134,8 @@ export type ContractClassPublic = {
   unconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[];
 } & Pick<ContractClassCommitments, 'id' | 'privateFunctionsRoot'> &
   Omit<ContractClass, 'privateFunctions'>;
-export type ContractClassWithCommitment = ContractClassPublic &
+
+export type ContractClassPublicWithCommitment = ContractClassPublic &
   Pick<ContractClassCommitments, 'publicBytecodeCommitment'>;
 
 export const ContractClassPublicSchema = z

package/src/contract/interfaces/contract_data_source.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 
-import { FunctionSelector } from '../../abi/index.js';
+import type { FunctionSelector } from '../../abi/index.js';
 import type { AztecAddress } from '../../aztec-address/index.js';
 import type { ContractClassPublic } from './contract_class.js';
 import type { ContractInstanceWithAddress } from './contract_instance.js';
@@ -32,8 +32,8 @@ export interface ContractDataSource {
    */
   getContractClassIds(): Promise<Fr[]>;
 
-  /** Returns a function's name */
-  getContractFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+  /** Returns a function's name. It's only available if provided by calling `registerContractFunctionSignatures`. */
+  getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
   /** Registers a function names. Useful for debugging. */
   registerContractFunctionSignatures(address: AztecAddress, signatures: string[]): Promise<void>;
 }

package/src/hash/hash.ts

@@ -80,8 +80,9 @@ export function computePublicDataTreeLeafSlot(contractAddress: AztecAddress, sto
 
 /**
  * Computes the hash of a list of arguments.
+ * Used for input arguments or return values for private functions, or for authwit creation.
  * @param args - Arguments to hash.
- * @returns Pedersen hash of the arguments.
+ * @returns Hash of the arguments.
  */
 export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   if (args.length === 0) {
@@ -91,6 +92,19 @@ export function computeVarArgsHash(args: Fr[]): Promise<Fr> {
   return poseidon2HashWithSeparator(args, GeneratorIndex.FUNCTION_ARGS);
 }
 
+/**
+ * Computes the hash of a public function's calldata.
+ * @param calldata - Calldata to hash.
+ * @returns Hash of the calldata.
+ */
+export function computeCalldataHash(calldata: Fr[]): Promise<Fr> {
+  if (calldata.length === 0) {
+    return Promise.resolve(Fr.ZERO);
+  }
+
+  return poseidon2HashWithSeparator(calldata, GeneratorIndex.PUBLIC_CALLDATA);
+}
+
 /**
  * Computes a hash of a secret.
  * @dev This function is used to generate secrets for the L1 to L2 message flow and for the TransparentNote.

package/src/interfaces/archiver.ts

@@ -72,9 +72,6 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
   getL1ToL2Messages: z.function().args(schemas.BigInt).returns(z.array(schemas.Fr)),
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
-  getContractFunctionName: z
-    .function()
-    .args(schemas.AztecAddress, schemas.FunctionSelector)
-    .returns(optional(z.string())),
+  getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
 };

package/src/interfaces/prover-client.ts

@@ -51,7 +51,7 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   realProofs: {
     env: 'PROVER_REAL_PROOFS',
     description: 'Whether to construct real proofs',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(true),
   },
   proverId: {
     env: 'PROVER_ID',

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/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 {