@aztec/aztec.js 0.71.0 → 0.73.0

package/src/contract/deploy_method.ts

@@ -100,7 +100,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     // in case the initializer is public. This hints at the need of having "transient" contracts scoped to a
     // simulation, so we can run the simulation with a set of contracts, but only "commit" them to the wallet
     // once this tx has gone through.
-    await this.wallet.registerContract({ artifact: this.artifact, instance: this.getInstance(options) });
+    await this.wallet.registerContract({ artifact: this.artifact, instance: await this.getInstance(options) });
 
     const bootstrap = await this.getInitializeFunctionCalls(options);
 
@@ -124,7 +124,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    */
   public async register(options: DeployOptions = {}): Promise<TContract> {
-    const instance = this.getInstance(options);
+    const instance = await this.getInstance(options);
     await this.wallet.registerContract({ artifact: this.artifact, instance });
     return this.postDeployCtor(instance.address, this.wallet);
   }
@@ -140,11 +140,11 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     const calls: FunctionCall[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
-    const instance = this.getInstance(options);
+    const instance = await this.getInstance(options);
 
     // Obtain contract class from artifact and check it matches the reported one by the instance.
     // TODO(@spalladino): We're unnecessarily calculating the contract class multiple times here.
-    const contractClass = getContractClassFromArtifact(this.artifact);
+    const contractClass = await getContractClassFromArtifact(this.artifact);
     if (!instance.contractClassId.equals(contractClass.id)) {
       throw new Error(
         `Contract class mismatch when deploying contract: got ${instance.contractClassId.toString()} from instance and ${contractClass.id.toString()} from artifact`,
@@ -153,7 +153,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
 
     // Register the contract class if it hasn't been published already.
     if (!options.skipClassRegistration) {
-      if (await this.wallet.isContractClassPubliclyRegistered(contractClass.id)) {
+      if ((await this.wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered) {
         this.log.debug(
           `Skipping registration of already registered contract class ${contractClass.id.toString()} for ${instance.address.toString()}`,
         );
@@ -161,13 +161,15 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
         this.log.info(
           `Creating request for registering contract class ${contractClass.id.toString()} as part of deployment for ${instance.address.toString()}`,
         );
-        calls.push((await registerContractClass(this.wallet, this.artifact)).request());
+        const registerContractClassInteraction = await registerContractClass(this.wallet, this.artifact);
+        calls.push(await registerContractClassInteraction.request());
       }
     }
 
     // Deploy the contract via the instance deployer.
     if (!options.skipPublicDeployment) {
-      calls.push(deployInstance(this.wallet, instance).request());
+      const deploymentInteraction = await deployInstance(this.wallet, instance);
+      calls.push(await deploymentInteraction.request());
     }
 
     return { calls };
@@ -178,10 +180,10 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns - An array of function calls.
    */
-  protected getInitializeFunctionCalls(
+  protected async getInitializeFunctionCalls(
     options: DeployOptions,
   ): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments'>> {
-    const { address } = this.getInstance(options);
+    const { address } = await this.getInstance(options);
     const calls: FunctionCall[] = [];
     if (this.constructorArtifact && !options.skipInitialization) {
       const constructorCall = new ContractFunctionInteraction(
@@ -190,9 +192,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
         this.constructorArtifact,
         this.args,
       );
-      calls.push(constructorCall.request());
+      calls.push(await constructorCall.request());
     }
-    return Promise.resolve({ calls });
+    return { calls };
   }
 
   /**
@@ -205,11 +207,8 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public override send(options: DeployOptions = {}): DeploySentTx<TContract> {
     const txHashPromise = super.send(options).getTxHash();
-    const instance = this.getInstance(options);
-    this.log.debug(
-      `Sent deployment tx of ${this.artifact.name} contract with deployment address ${instance.address.toString()}`,
-    );
-    return new DeploySentTx(this.wallet, txHashPromise, this.postDeployCtor, instance);
+    this.log.debug(`Sent deployment tx of ${this.artifact.name} contract`);
+    return new DeploySentTx(this.wallet, txHashPromise, this.postDeployCtor, () => this.getInstance(options));
   }
 
   /**
@@ -218,9 +217,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - An object containing various deployment options.
    * @returns An instance object.
    */
-  public getInstance(options: DeployOptions = {}): ContractInstanceWithAddress {
+  public async getInstance(options: DeployOptions = {}): Promise<ContractInstanceWithAddress> {
     if (!this.instance) {
-      this.instance = getContractInstanceFromDeployParams(this.artifact, {
+      this.instance = await getContractInstanceFromDeployParams(this.artifact, {
         constructorArgs: this.args,
         salt: options.contractAddressSalt,
         publicKeys: this.publicKeys,
@@ -238,8 +237,9 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public override async prove(options: DeployOptions): Promise<DeployProvenTx<TContract>> {
     const txProvingResult = await this.proveInternal(options);
-    const instance = this.getInstance(options);
-    return new DeployProvenTx(this.wallet, txProvingResult.toTx(), this.postDeployCtor, instance);
+    return new DeployProvenTx(this.wallet, txProvingResult.toTx(), this.postDeployCtor, () =>
+      this.getInstance(options),
+    );
   }
 
   /**

package/src/contract/deploy_proven_tx.ts

@@ -14,7 +14,7 @@ export class DeployProvenTx<TContract extends Contract = Contract> extends Prove
     wallet: PXE | Wallet,
     tx: Tx,
     private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    private instance: ContractInstanceWithAddress,
+    private instanceGetter: () => Promise<ContractInstanceWithAddress>,
   ) {
     super(wallet, tx);
   }
@@ -27,6 +27,6 @@ export class DeployProvenTx<TContract extends Contract = Contract> extends Prove
       return this.wallet.sendTx(this.getPlainDataTx());
     })();
 
-    return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instance);
+    return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instanceGetter);
   }
 }

package/src/contract/deploy_sent_tx.ts

@@ -30,8 +30,8 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
     wallet: PXE | Wallet,
     txHashPromise: Promise<TxHash>,
     private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
-    /** The deployed contract instance */
-    public instance: ContractInstanceWithAddress,
+    /** A getter for the deployed contract instance */
+    public instanceGetter: () => Promise<ContractInstanceWithAddress>,
   ) {
     super(wallet, txHashPromise);
   }
@@ -43,7 +43,8 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
    */
   public async deployed(opts?: DeployedWaitOpts): Promise<TContract> {
     const receipt = await this.wait(opts);
-    this.log.info(`Contract ${this.instance.address.toString()} successfully deployed.`);
+    const instance = await this.instanceGetter();
+    this.log.info(`Contract ${instance.address.toString()} successfully deployed.`);
     return receipt.contract;
   }
 
@@ -58,12 +59,13 @@ export class DeploySentTx<TContract extends Contract = Contract> extends SentTx
     return { ...receipt, contract };
   }
 
-  protected getContractObject(wallet?: Wallet): Promise<TContract> {
+  protected async getContractObject(wallet?: Wallet): Promise<TContract> {
     const isWallet = (pxe: PXE | Wallet): pxe is Wallet => !!(pxe as Wallet).createTxExecutionRequest;
     const contractWallet = wallet ?? (isWallet(this.pxe) && this.pxe);
     if (!contractWallet) {
       throw new Error(`A wallet is required for creating a contract instance`);
     }
-    return this.postDeployCtor(this.instance.address, contractWallet) as Promise<TContract>;
+    const instance = await this.instanceGetter();
+    return this.postDeployCtor(instance.address, contractWallet) as Promise<TContract>;
   }
 }

package/src/contract/proven_tx.ts

@@ -11,7 +11,6 @@ export class ProvenTx extends Tx {
     super(
       tx.data,
       tx.clientIvcProof,
-      tx.unencryptedLogs,
       tx.contractClassLogs,
       tx.enqueuedPublicFunctionCalls,
       tx.publicTeardownFunctionCall,
@@ -23,7 +22,6 @@ export class ProvenTx extends Tx {
     return new Tx(
       this.data,
       this.clientIvcProof,
-      this.unencryptedLogs,
       this.contractClassLogs,
       this.enqueuedPublicFunctionCalls,
       this.publicTeardownFunctionCall,

package/src/contract/sent_tx.ts

@@ -1,4 +1,4 @@
-import { type GetUnencryptedLogsResponse, type PXE, type TxHash, type TxReceipt, TxStatus } from '@aztec/circuit-types';
+import { type GetPublicLogsResponse, type PXE, type TxHash, type TxReceipt, TxStatus } from '@aztec/circuit-types';
 import { retryUntil } from '@aztec/foundation/retry';
 import { type FieldsOf } from '@aztec/foundation/types';
 
@@ -87,13 +87,13 @@ export class SentTx {
   }
 
   /**
-   * Gets unencrypted logs emitted by this tx.
+   * Gets public logs emitted by this tx.
    * @remarks This function will wait for the tx to be mined if it hasn't been already.
    * @returns The requested logs.
    */
-  public async getUnencryptedLogs(): Promise<GetUnencryptedLogsResponse> {
+  public async getPublicLogs(): Promise<GetPublicLogsResponse> {
     await this.wait();
-    return this.pxe.getUnencryptedLogs({ txHash: await this.getTxHash() });
+    return this.pxe.getPublicLogs({ txHash: await this.getTxHash() });
   }
 
   protected async waitForReceipt(opts?: WaitOpts): Promise<TxReceipt> {

package/src/deployment/broadcast_function.ts

@@ -6,7 +6,7 @@ import {
   createUnconstrainedFunctionMembershipProof,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
-import { type ContractArtifact, type FunctionSelector, FunctionType, bufferAsFields } from '@aztec/foundation/abi';
+import { type ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -28,8 +28,15 @@ export async function broadcastPrivateFunction(
   artifact: ContractArtifact,
   selector: FunctionSelector,
 ): Promise<ContractFunctionInteraction> {
-  const contractClass = getContractClassFromArtifact(artifact);
-  const privateFunctionArtifact = artifact.functions.find(fn => selector.equals(fn));
+  const contractClass = await getContractClassFromArtifact(artifact);
+  const privateFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.PRIVATE);
+  const functionsAndSelectors = await Promise.all(
+    privateFunctions.map(async fn => ({
+      f: fn,
+      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
+    })),
+  );
+  const privateFunctionArtifact = functionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
   if (!privateFunctionArtifact) {
     throw new Error(`Private function with selector ${selector.toString()} not found`);
   }
@@ -42,9 +49,9 @@ export async function broadcastPrivateFunction(
     unconstrainedFunctionsArtifactTreeRoot,
     privateFunctionTreeSiblingPath,
     privateFunctionTreeLeafIndex,
-  } = createPrivateFunctionMembershipProof(selector, artifact);
+  } = await createPrivateFunctionMembershipProof(selector, artifact);
 
-  const vkHash = computeVerificationKeyHash(privateFunctionArtifact);
+  const vkHash = await computeVerificationKeyHash(privateFunctionArtifact);
   const bytecode = bufferAsFields(
     privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
@@ -52,7 +59,7 @@ export async function broadcastPrivateFunction(
 
   await wallet.addCapsule(bytecode);
 
-  const registerer = getRegistererContract(wallet);
+  const registerer = await getRegistererContract(wallet);
   return Promise.resolve(
     registerer.methods.broadcast_private_function(
       contractClass.id,
@@ -82,14 +89,18 @@ export async function broadcastUnconstrainedFunction(
   artifact: ContractArtifact,
   selector: FunctionSelector,
 ): Promise<ContractFunctionInteraction> {
-  const contractClass = getContractClassFromArtifact(artifact);
-  const functionArtifactIndex = artifact.functions.findIndex(
-    fn => fn.functionType === FunctionType.UNCONSTRAINED && selector.equals(fn),
+  const contractClass = await getContractClassFromArtifact(artifact);
+  const unconstrainedFunctions = artifact.functions.filter(fn => fn.functionType === FunctionType.UNCONSTRAINED);
+  const unconstrainedFunctionsAndSelectors = await Promise.all(
+    unconstrainedFunctions.map(async fn => ({
+      f: fn,
+      selector: await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters),
+    })),
   );
-  if (functionArtifactIndex < 0) {
+  const unconstrainedFunctionArtifact = unconstrainedFunctionsAndSelectors.find(fn => selector.equals(fn.selector))?.f;
+  if (!unconstrainedFunctionArtifact) {
     throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
   }
-  const functionArtifact = artifact.functions[functionArtifactIndex];
 
   const {
     artifactMetadataHash,
@@ -97,13 +108,16 @@ export async function broadcastUnconstrainedFunction(
     artifactTreeSiblingPath,
     functionMetadataHash,
     privateFunctionsArtifactTreeRoot,
-  } = createUnconstrainedFunctionMembershipProof(selector, artifact);
+  } = await createUnconstrainedFunctionMembershipProof(selector, artifact);
 
-  const bytecode = bufferAsFields(functionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
+  const bytecode = bufferAsFields(
+    unconstrainedFunctionArtifact.bytecode,
+    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
+  );
 
   await wallet.addCapsule(bytecode);
 
-  const registerer = getRegistererContract(wallet);
+  const registerer = await getRegistererContract(wallet);
   return registerer.methods.broadcast_unconstrained_function(
     contractClass.id,
     artifactMetadataHash,

package/src/deployment/deploy_instance.ts

@@ -9,8 +9,11 @@ import { getDeployerContract } from './protocol_contracts.js';
  * @param wallet - The wallet to use for the deployment.
  * @param instance - The instance to deploy.
  */
-export function deployInstance(wallet: Wallet, instance: ContractInstanceWithAddress): ContractFunctionInteraction {
-  const deployerContract = getDeployerContract(wallet);
+export async function deployInstance(
+  wallet: Wallet,
+  instance: ContractInstanceWithAddress,
+): Promise<ContractFunctionInteraction> {
+  const deployerContract = await getDeployerContract(wallet);
   const { salt, contractClassId, publicKeys, deployer } = instance;
   const isUniversalDeploy = deployer.isZero();
   if (!isUniversalDeploy && !wallet.getAddress().equals(deployer)) {

package/src/deployment/protocol_contracts.ts

@@ -5,13 +5,13 @@ import { UnsafeContract } from '../contract/unsafe_contract.js';
 import { type Wallet } from '../wallet/index.js';
 
 /** Returns a Contract wrapper for the class registerer. */
-export function getRegistererContract(wallet: Wallet) {
-  const { artifact, instance } = getCanonicalClassRegisterer();
+export async function getRegistererContract(wallet: Wallet) {
+  const { artifact, instance } = await getCanonicalClassRegisterer();
   return new UnsafeContract(instance, artifact, wallet);
 }
 
 /** Returns a Contract wrapper for the instance deployer. */
-export function getDeployerContract(wallet: Wallet) {
-  const { artifact, instance } = getCanonicalInstanceDeployer();
+export async function getDeployerContract(wallet: Wallet) {
+  const { artifact, instance } = await getCanonicalInstanceDeployer();
   return new UnsafeContract(instance, artifact, wallet);
 }

package/src/deployment/register_class.ts

@@ -18,9 +18,9 @@ export async function registerContractClass(
   emitPublicBytecode = defaultEmitPublicBytecode,
 ): Promise<ContractFunctionInteraction> {
   const { artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode } =
-    getContractClassFromArtifact(artifact);
+    await getContractClassFromArtifact(artifact);
   const encodedBytecode = bufferAsFields(packedBytecode, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);
-  const registerer = getRegistererContract(wallet);
+  const registerer = await getRegistererContract(wallet);
   await wallet.addCapsule(encodedBytecode);
   return registerer.methods.register(artifactHash, privateFunctionsRoot, publicBytecodeCommitment, emitPublicBytecode);
 }

package/src/entrypoint/default_entrypoint.ts

@@ -10,7 +10,7 @@ import { type EntrypointInterface, type ExecutionRequestInit } from './entrypoin
 export class DefaultEntrypoint implements EntrypointInterface {
   constructor(private chainId: number, private protocolVersion: number) {}
 
-  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+  async createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
     const { fee, calls, authWitnesses = [], hashedArguments = [] } = exec;
 
     if (calls.length > 1) {
@@ -23,7 +23,7 @@ export class DefaultEntrypoint implements EntrypointInterface {
       throw new Error('Public entrypoints are not allowed');
     }
 
-    const entrypointHashedValues = HashedValues.fromValues(call.args);
+    const entrypointHashedValues = await HashedValues.fromValues(call.args);
     const txContext = new TxContext(this.chainId, this.protocolVersion, fee.gasSettings);
     return Promise.resolve(
       new TxExecutionRequest(

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -14,16 +14,16 @@ export class DefaultMultiCallEntrypoint implements EntrypointInterface {
     private address: AztecAddress = ProtocolContractAddress.MultiCallEntrypoint,
   ) {}
 
-  createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
+  async createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
     const { fee, calls, authWitnesses = [], hashedArguments = [] } = executions;
-    const payload = EntrypointPayload.fromAppExecution(calls);
+    const payload = await EntrypointPayload.fromAppExecution(calls);
     const abi = this.getEntrypointAbi();
-    const entrypointHashedArgs = HashedValues.fromValues(encodeArguments(abi, [payload]));
+    const entrypointHashedArgs = await HashedValues.fromValues(encodeArguments(abi, [payload]));
 
     const txRequest = TxExecutionRequest.from({
       firstCallArgsHash: entrypointHashedArgs.hash,
       origin: this.address,
-      functionSelector: FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
+      functionSelector: await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
       txContext: new TxContext(this.chainId, this.version, fee.gasSettings),
       argsOfCalls: [...payload.hashedArguments, ...hashedArguments, entrypointHashedArgs],
       authWitnesses,

package/src/entrypoint/payload.ts

@@ -24,6 +24,8 @@ export type UserFeeOptions = {
   paymentMethod?: FeePaymentMethod;
   /** The gas settings */
   gasSettings?: Partial<FieldsOf<GasSettings>>;
+  /** Percentage to pad the base fee by, if empty, defaults to 0.5 */
+  baseFeePadding?: number;
   /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings. */
   estimateGas?: boolean;
   /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
@@ -54,19 +56,22 @@ type EncodedFunctionCall = {
 
 /** Assembles an entrypoint payload */
 export abstract class EntrypointPayload {
-  #hashedArguments: HashedValues[] = [];
-  #functionCalls: EncodedFunctionCall[] = [];
-  #nonce: Fr;
-  #generatorIndex: number;
-
-  protected constructor(functionCalls: FunctionCall[], generatorIndex: number, nonce = Fr.random()) {
+  protected constructor(
+    private functionCalls: EncodedFunctionCall[],
+    private _hashedArguments: HashedValues[],
+    private generatorIndex: number,
+    private _nonce: Fr,
+  ) {}
+
+  protected static async create(functionCalls: FunctionCall[]) {
+    const hashedArguments: HashedValues[] = [];
     for (const call of functionCalls) {
-      this.#hashedArguments.push(HashedValues.fromValues(call.args));
+      hashedArguments.push(await HashedValues.fromValues(call.args));
     }
 
     /* eslint-disable camelcase */
-    this.#functionCalls = functionCalls.map((call, index) => ({
-      args_hash: this.#hashedArguments[index].hash,
+    const encodedFunctionCalls = functionCalls.map((call, index) => ({
+      args_hash: hashedArguments[index].hash,
       function_selector: call.selector.toField(),
       target_address: call.to.toField(),
       is_public: call.type == FunctionType.PUBLIC,
@@ -74,8 +79,10 @@ export abstract class EntrypointPayload {
     }));
     /* eslint-enable camelcase */
 
-    this.#generatorIndex = generatorIndex;
-    this.#nonce = nonce;
+    return {
+      encodedFunctionCalls,
+      hashedArguments,
+    };
   }
 
   /* eslint-disable camelcase */
@@ -84,7 +91,7 @@ export abstract class EntrypointPayload {
    * @internal
    */
   get function_calls() {
-    return this.#functionCalls;
+    return this.functionCalls;
   }
   /* eslint-enable camelcase */
 
@@ -93,14 +100,14 @@ export abstract class EntrypointPayload {
    * @internal
    */
   get nonce() {
-    return this.#nonce;
+    return this._nonce;
   }
 
   /**
    * The hashed arguments for the function calls
    */
   get hashedArguments() {
-    return this.#hashedArguments;
+    return this._hashedArguments;
   }
 
   /**
@@ -114,12 +121,12 @@ export abstract class EntrypointPayload {
    * @returns The hash of the payload
    */
   hash() {
-    return poseidon2HashWithSeparator(this.toFields(), this.#generatorIndex);
+    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
   }
 
   /** Serializes the function calls to an array of fields. */
   protected functionCallsToFields() {
-    return this.#functionCalls.flatMap(call => [
+    return this.functionCalls.flatMap(call => [
       call.args_hash,
       call.function_selector,
       call.target_address,
@@ -133,8 +140,9 @@ export abstract class EntrypointPayload {
    * @param functionCalls - The function calls to execute
    * @returns The execution payload
    */
-  static fromFunctionCalls(functionCalls: FunctionCall[]) {
-    return new AppEntrypointPayload(functionCalls, 0);
+  static async fromFunctionCalls(functionCalls: FunctionCall[]) {
+    const { encodedFunctionCalls, hashedArguments } = await this.create(functionCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, 0, Fr.random());
   }
 
   /**
@@ -143,12 +151,13 @@ export abstract class EntrypointPayload {
    * @param nonce - The nonce for the payload, used to emit a nullifier identifying the call
    * @returns The execution payload
    */
-  static fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
+  static async fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
     if (functionCalls.length > APP_MAX_CALLS) {
       throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
     }
     const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
-    return new AppEntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
   }
 
   /**
@@ -162,7 +171,14 @@ export abstract class EntrypointPayload {
     const feePayer = await feeOpts?.paymentMethod.getFeePayer(feeOpts?.gasSettings);
     const isFeePayer = !!feePayer && feePayer.equals(sender);
     const paddedCalls = padArrayEnd(calls, FunctionCall.empty(), FEE_MAX_CALLS);
-    return new FeeEntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD, isFeePayer);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new FeeEntrypointPayload(
+      encodedFunctionCalls,
+      hashedArguments,
+      GeneratorIndex.FEE_PAYLOAD,
+      Fr.random(),
+      isFeePayer,
+    );
   }
 }
 
@@ -177,8 +193,14 @@ class AppEntrypointPayload extends EntrypointPayload {
 class FeeEntrypointPayload extends EntrypointPayload {
   #isFeePayer: boolean;
 
-  constructor(functionCalls: FunctionCall[], generatorIndex: number, isFeePayer: boolean) {
-    super(functionCalls, generatorIndex);
+  constructor(
+    functionCalls: EncodedFunctionCall[],
+    hashedArguments: HashedValues[],
+    generatorIndex: number,
+    nonce: Fr,
+    isFeePayer: boolean,
+  ) {
+    super(functionCalls, hashedArguments, generatorIndex, nonce);
     this.#isFeePayer = isFeePayer;
   }
 
@@ -200,6 +222,12 @@ class FeeEntrypointPayload extends EntrypointPayload {
  * @param feePayload - A fee payload.
  * @returns A hash of a combined payload.
  */
-export function computeCombinedPayloadHash(appPayload: AppEntrypointPayload, feePayload: FeeEntrypointPayload): Fr {
-  return poseidon2HashWithSeparator([appPayload.hash(), feePayload.hash()], GeneratorIndex.COMBINED_PAYLOAD);
+export async function computeCombinedPayloadHash(
+  appPayload: AppEntrypointPayload,
+  feePayload: FeeEntrypointPayload,
+): Promise<Fr> {
+  return poseidon2HashWithSeparator(
+    [await appPayload.hash(), await feePayload.hash()],
+    GeneratorIndex.COMBINED_PAYLOAD,
+  );
 }

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -1,6 +1,6 @@
 import { type FunctionCall } from '@aztec/circuit-types';
 import { type AztecAddress, Fr, FunctionSelector } from '@aztec/circuits.js';
-import { FunctionType } from '@aztec/foundation/abi';
+import { FunctionType, U128 } from '@aztec/foundation/abi';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 
@@ -22,9 +22,10 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
    * Creates a function call to pay the fee in Fee Juice.
    * @returns A function call
    */
-  override getFunctionCalls(): Promise<FunctionCall[]> {
-    const selector = FunctionSelector.fromNameAndParameters(
-      getCanonicalFeeJuice().artifact.functions.find(f => f.name === 'claim')!,
+  override async getFunctionCalls(): Promise<FunctionCall[]> {
+    const canonicalFeeJuice = await getCanonicalFeeJuice();
+    const selector = await FunctionSelector.fromNameAndParameters(
+      canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
     );
 
     return Promise.resolve([
@@ -35,7 +36,7 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
         isStatic: false,
         args: [
           this.sender.toField(),
-          this.claim.claimAmount,
+          ...new U128(this.claim.claimAmount).toFields(),
           this.claim.claimSecret,
           new Fr(this.claim.messageLeafIndex),
         ],

package/src/fee/private_fee_payment_method.ts

@@ -1,6 +1,6 @@
 import { type FunctionCall } from '@aztec/circuit-types';
 import { type GasSettings } from '@aztec/circuits.js';
-import { FunctionSelector, FunctionType } from '@aztec/foundation/abi';
+import { FunctionSelector, FunctionType, U128 } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -88,15 +88,15 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
   async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
     // We assume 1:1 exchange rate between fee juice and token. But in reality you would need to convert feeLimit
     // (maxFee) to be in token denomination.
-    const maxFee = this.setMaxFeeToOne ? Fr.ONE : gasSettings.getFeeLimit();
+    const maxFee = new U128(this.setMaxFeeToOne ? 1n : gasSettings.getFeeLimit().toBigInt());
     const nonce = Fr.random();
 
     await this.wallet.createAuthWit({
       caller: this.paymentContract,
       action: {
-        name: 'setup_refund',
-        args: [this.wallet.getAddress().toField(), maxFee, nonce],
-        selector: FunctionSelector.fromSignature('setup_refund((Field),Field,Field)'),
+        name: 'transfer_to_public',
+        args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), ...maxFee.toFields(), nonce],
+        selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),(Field,Field),Field)'),
         type: FunctionType.PRIVATE,
         isStatic: false,
         to: await this.getAsset(),
@@ -108,10 +108,10 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
       {
         name: 'fee_entrypoint_private',
         to: this.paymentContract,
-        selector: FunctionSelector.fromSignature('fee_entrypoint_private(Field,Field)'),
+        selector: await FunctionSelector.fromSignature('fee_entrypoint_private((Field,Field),Field)'),
         type: FunctionType.PRIVATE,
         isStatic: false,
-        args: [maxFee, nonce],
+        args: [...maxFee.toFields(), nonce],
         returnTypes: [],
       },
     ];