@aztec/aztec.js 0.34.0 → 0.35.0

package/src/contract/contract_function_interaction.ts

@@ -1,5 +1,5 @@
-import { type FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData, TxContext } from '@aztec/circuits.js';
+import { type FunctionCall, PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
 import { type FunctionAbi, FunctionType, encodeArguments } from '@aztec/foundation/abi';
 
 import { type Wallet } from '../account/wallet.js';
@@ -13,10 +13,10 @@ export { SendMethodOptions };
  * Disregarded for simulation of public functions
  */
 export type SimulateMethodOptions = {
-  /**
-   * The sender's Aztec address.
-   */
+  /** The sender's Aztec address. */
   from?: AztecAddress;
+  /** Gas settings for the simulation. */
+  gasSettings?: GasSettings;
 };
 
 /**
@@ -47,7 +47,10 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
       throw new Error("Can't call `create` on an unconstrained function.");
     }
     if (!this.txRequest) {
-      this.txRequest = await this.wallet.createTxExecutionRequest([this.request()], opts?.fee);
+      this.txRequest = await this.wallet.createTxExecutionRequest({
+        calls: [this.request()],
+        fee: opts?.fee,
+      });
     }
     return this.txRequest;
   }
@@ -89,7 +92,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
 
     if (this.functionDao.functionType == FunctionType.SECRET) {
       const nodeInfo = await this.wallet.getNodeInfo();
-      const packedArgs = PackedArguments.fromArgs(encodeArguments(this.functionDao, this.args));
+      const packedArgs = PackedValues.fromValues(encodeArguments(this.functionDao, this.args));
 
       const txRequest = TxExecutionRequest.from({
         argsHash: packedArgs.hash,
@@ -98,6 +101,7 @@ export class ContractFunctionInteraction extends BaseContractInteraction {
         txContext: TxContext.empty(nodeInfo.chainId, nodeInfo.protocolVersion),
         packedArguments: [packedArgs],
         authWitnesses: [],
+        gasSettings: options.gasSettings ?? GasSettings.simulation(),
       });
       const simulatedTx = await this.pxe.simulateTx(txRequest, false, options.from ?? this.wallet.getAddress());
       return simulatedTx.privateReturnValues?.[0];

package/src/contract/deploy_method.ts

@@ -14,6 +14,7 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type Wallet } from '../account/index.js';
 import { deployInstance } from '../deployment/deploy_instance.js';
 import { registerContractClass } from '../deployment/register_class.js';
+import { type ExecutionRequestInit } from '../entrypoint/entrypoint.js';
 import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
 import { type Contract } from './contract.js';
 import { type ContractBase } from './contract_base.js';
@@ -53,7 +54,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
   private constructorArtifact: FunctionArtifact | undefined;
 
   /** Cached call to request() */
-  private functionCalls: FunctionCall[] | undefined;
+  private functionCalls?: ExecutionRequestInit;
 
   private log = createDebugLogger('aztec:js:deploy_method');
 
@@ -80,10 +81,6 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    */
   public async create(options: DeployOptions = {}): Promise<TxExecutionRequest> {
     if (!this.txRequest) {
-      const calls = await this.request(options);
-      if (calls.length === 0) {
-        throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
-      }
       this.txRequest = await this.wallet.createTxExecutionRequest(await this.request(options));
       // TODO: Should we add the contracts to the DB here, or once the tx has been sent or mined?
       await this.pxe.registerContract({ artifact: this.artifact, instance: this.instance! });
@@ -99,20 +96,21 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @remarks This method does not have the same return type as the `request` in the ContractInteraction object,
    * it returns a promise for an array instead of a function call directly.
    */
-  public async request(options: DeployOptions = {}): Promise<FunctionCall[]> {
+  public async request(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
     if (!this.functionCalls) {
-      const { address } = this.getInstance(options);
-      const calls = await this.getDeploymentFunctionCalls(options);
-      if (this.constructorArtifact && !options.skipInitialization) {
-        const constructorCall = new ContractFunctionInteraction(
-          this.wallet,
-          address,
-          this.constructorArtifact,
-          this.args,
-        );
-        calls.push(constructorCall.request());
+      const deployment = await this.getDeploymentFunctionCalls(options);
+      const bootstrap = await this.getInitializeFunctionCalls(options);
+
+      if (deployment.calls.length + bootstrap.calls.length === 0) {
+        throw new Error(`No function calls needed to deploy contract ${this.artifact.name}`);
       }
-      this.functionCalls = calls;
+
+      this.functionCalls = {
+        calls: [...deployment.calls, ...bootstrap.calls],
+        authWitnesses: [...(deployment.authWitnesses ?? []), ...(bootstrap.authWitnesses ?? [])],
+        packedArguments: [...(deployment.packedArguments ?? []), ...(bootstrap.packedArguments ?? [])],
+        fee: options.fee,
+      };
     }
     return this.functionCalls;
   }
@@ -122,7 +120,7 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
    * @param options - Deployment options.
    * @returns A function call array with potentially requests to the class registerer and instance deployer.
    */
-  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<FunctionCall[]> {
+  protected async getDeploymentFunctionCalls(options: DeployOptions = {}): Promise<ExecutionRequestInit> {
     const calls: FunctionCall[] = [];
 
     // Set contract instance object so it's available for populating the DeploySendTx object
@@ -156,7 +154,31 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
       calls.push(deployInstance(this.wallet, instance).request());
     }
 
-    return calls;
+    return {
+      calls,
+    };
+  }
+
+  /**
+   * Returns the calls necessary to initialize the contract.
+   * @param options - Deployment options.
+   * @returns - An array of function calls.
+   */
+  protected getInitializeFunctionCalls(options: DeployOptions): Promise<ExecutionRequestInit> {
+    const { address } = this.getInstance(options);
+    const calls: FunctionCall[] = [];
+    if (this.constructorArtifact && !options.skipInitialization) {
+      const constructorCall = new ContractFunctionInteraction(
+        this.wallet,
+        address,
+        this.constructorArtifact,
+        this.args,
+      );
+      calls.push(constructorCall.request());
+    }
+    return Promise.resolve({
+      calls,
+    });
   }
 
   /**

package/src/entrypoint/default_entrypoint.ts

@@ -1,7 +1,7 @@
-import { type FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { TxContext } from '@aztec/circuits.js';
+import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { GasSettings, TxContext } from '@aztec/circuits.js';
 
-import { type EntrypointInterface } from './entrypoint.js';
+import { type EntrypointInterface, type ExecutionRequestInit } from './entrypoint.js';
 
 /**
  * Default implementation of the entrypoint interface. It calls a function on a contract directly
@@ -9,18 +9,25 @@ import { type EntrypointInterface } from './entrypoint.js';
 export class DefaultEntrypoint implements EntrypointInterface {
   constructor(private chainId: number, private protocolVersion: number) {}
 
-  createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    const [execution] = executions;
-    const packedArguments = PackedArguments.fromArgs(execution.args);
+  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { calls, authWitnesses = [], packedArguments = [] } = exec;
+
+    if (calls.length > 1) {
+      throw new Error(`Expected a single call, got ${calls.length}`);
+    }
+
+    const call = calls[0];
+    const entrypointPackedValues = PackedValues.fromValues(call.args);
     const txContext = TxContext.empty(this.chainId, this.protocolVersion);
     return Promise.resolve(
       new TxExecutionRequest(
-        execution.to,
-        execution.functionData,
-        packedArguments.hash,
+        call.to,
+        call.functionData,
+        entrypointPackedValues.hash,
         txContext,
-        [packedArguments],
-        [],
+        [...packedArguments, entrypointPackedValues],
+        authWitnesses,
+        exec.fee?.gasSettings ?? GasSettings.default(),
       ),
     );
   }

package/src/entrypoint/default_multi_call_entrypoint.ts

@@ -0,0 +1,89 @@
+import { type EntrypointInterface, EntrypointPayload, type ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { PackedValues, TxExecutionRequest } from '@aztec/circuit-types';
+import { type AztecAddress, FunctionData, GasSettings, TxContext } from '@aztec/circuits.js';
+import { type FunctionAbi, encodeArguments } from '@aztec/foundation/abi';
+import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
+
+/**
+ * Implementation for an entrypoint interface that can execute multiple function calls in a single transaction
+ */
+export class DefaultMultiCallEntrypoint implements EntrypointInterface {
+  constructor(
+    private chainId: number,
+    private version: number,
+    private address: AztecAddress = getCanonicalMultiCallEntrypointAddress(),
+  ) {}
+
+  createTxExecutionRequest(executions: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    const { calls, authWitnesses = [], packedArguments = [] } = executions;
+    const payload = EntrypointPayload.fromAppExecution(calls);
+    const abi = this.getEntrypointAbi();
+    const entrypointPackedArgs = PackedValues.fromValues(encodeArguments(abi, [payload]));
+
+    const txRequest = TxExecutionRequest.from({
+      argsHash: entrypointPackedArgs.hash,
+      origin: this.address,
+      functionData: FunctionData.fromAbi(abi),
+      txContext: TxContext.empty(this.chainId, this.version),
+      packedArguments: [...payload.packedArguments, ...packedArguments, entrypointPackedArgs],
+      authWitnesses,
+      gasSettings: executions.fee?.gasSettings ?? GasSettings.default(),
+    });
+
+    return Promise.resolve(txRequest);
+  }
+
+  private getEntrypointAbi() {
+    return {
+      name: 'entrypoint',
+      isInitializer: false,
+      functionType: 'secret',
+      isInternal: false,
+      parameters: [
+        {
+          name: 'app_payload',
+          type: {
+            kind: 'struct',
+            path: 'authwit::entrypoint::app::AppPayload',
+            fields: [
+              {
+                name: 'function_calls',
+                type: {
+                  kind: 'array',
+                  length: 4,
+                  type: {
+                    kind: 'struct',
+                    path: 'authwit::entrypoint::function_call::FunctionCall',
+                    fields: [
+                      { name: 'args_hash', type: { kind: 'field' } },
+                      {
+                        name: 'function_selector',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::abis::function_selector::FunctionSelector',
+                          fields: [{ name: 'inner', type: { kind: 'integer', sign: 'unsigned', width: 32 } }],
+                        },
+                      },
+                      {
+                        name: 'target_address',
+                        type: {
+                          kind: 'struct',
+                          path: 'authwit::aztec::protocol_types::address::AztecAddress',
+                          fields: [{ name: 'inner', type: { kind: 'field' } }],
+                        },
+                      },
+                      { name: 'is_public', type: { kind: 'boolean' } },
+                    ],
+                  },
+                },
+              },
+              { name: 'nonce', type: { kind: 'field' } },
+            ],
+          },
+          visibility: 'public',
+        },
+      ],
+      returnTypes: [],
+    } as FunctionAbi;
+  }
+}

package/src/entrypoint/entrypoint.ts

@@ -1,25 +1,30 @@
-import { type FunctionCall, type TxExecutionRequest } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/foundation/fields';
+import { type AuthWitness, type FunctionCall, type PackedValues, type TxExecutionRequest } from '@aztec/circuit-types';
 
-import { type FeePaymentMethod } from '../fee/fee_payment_method.js';
+import { EntrypointPayload, type FeeOptions } from './payload.js';
 
-/**
- * Fee payment options for a transaction.
- */
-export type FeeOptions = {
-  /** The fee payment method to use */
-  paymentMethod: FeePaymentMethod;
-  /** The fee limit to pay */
-  maxFee: bigint | number | Fr;
+export { EntrypointPayload, FeeOptions };
+
+export { DefaultEntrypoint } from './default_entrypoint.js';
+export { DefaultMultiCallEntrypoint } from './default_multi_call_entrypoint.js';
+
+/** Encodes the calls to be done in a transaction. */
+export type ExecutionRequestInit = {
+  /** The function calls to be executed. */
+  calls: FunctionCall[];
+  /** Any transient auth witnesses needed for this execution */
+  authWitnesses?: AuthWitness[];
+  /** Any transient packed arguments for this execution */
+  packedArguments?: PackedValues[];
+  /** How the fee is going to be payed */
+  fee?: FeeOptions;
 };
 
 /** Creates transaction execution requests out of a set of function calls. */
 export interface EntrypointInterface {
   /**
    * Generates an execution request out of set of function calls.
-   * @param executions - The execution intents to be run.
-   * @param feeOpts - The fee to be paid for the transaction.
+   * @param execution - The execution intents to be run.
    * @returns The authenticated transaction execution request.
    */
-  createTxExecutionRequest(executions: FunctionCall[], feeOpts?: FeeOptions): Promise<TxExecutionRequest>;
+  createTxExecutionRequest(execution: ExecutionRequestInit): Promise<TxExecutionRequest>;
 }

package/src/entrypoint/payload.ts

@@ -0,0 +1,144 @@
+import { type FunctionCall, PackedValues, emptyFunctionCall } from '@aztec/circuit-types';
+import { Fr, type GasSettings, GeneratorIndex } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+import { type FeePaymentMethod } from '../fee/fee_payment_method.js';
+
+/**
+ * Fee payment options for a transaction.
+ */
+export type FeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings: GasSettings;
+};
+
+// These must match the values defined in:
+// - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
+const APP_MAX_CALLS = 4;
+// - and noir-projects/aztec-nr/aztec/src/entrypoint/fee.nr
+const FEE_MAX_CALLS = 2;
+
+/* eslint-disable camelcase */
+/** Encoded function call for account contract entrypoint */
+type EncodedFunctionCall = {
+  /** Arguments hash for the call */
+  args_hash: Fr;
+  /** Selector of the function to call */
+  function_selector: Fr;
+  /** Address of the contract to call */
+  target_address: Fr;
+  /** Whether the function is public or private */
+  is_public: boolean;
+};
+/* eslint-enable camelcase */
+
+/** Assembles an entrypoint payload */
+export class EntrypointPayload {
+  #packedArguments: PackedValues[] = [];
+  #functionCalls: EncodedFunctionCall[] = [];
+  #nonce = Fr.random();
+  #generatorIndex: number;
+
+  private constructor(functionCalls: FunctionCall[], generatorIndex: number) {
+    for (const call of functionCalls) {
+      this.#packedArguments.push(PackedValues.fromValues(call.args));
+    }
+
+    /* eslint-disable camelcase */
+    this.#functionCalls = functionCalls.map((call, index) => ({
+      args_hash: this.#packedArguments[index].hash,
+      function_selector: call.functionData.selector.toField(),
+      target_address: call.to.toField(),
+      is_public: !call.functionData.isPrivate,
+    }));
+    /* eslint-enable camelcase */
+
+    this.#generatorIndex = generatorIndex;
+  }
+
+  /* eslint-disable camelcase */
+  /**
+   * The function calls to execute. This uses snake_case naming so that it is compatible with Noir encoding
+   * @internal
+   */
+  get function_calls() {
+    return this.#functionCalls;
+  }
+  /* eslint-enable camelcase */
+
+  /**
+   * The nonce
+   * @internal
+   */
+  get nonce() {
+    return this.#nonce;
+  }
+
+  /**
+   * The packed arguments for the function calls
+   */
+  get packedArguments() {
+    return this.#packedArguments;
+  }
+
+  /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */
+  toFields(): Fr[] {
+    return [
+      ...this.#functionCalls.flatMap(call => [
+        call.args_hash,
+        call.function_selector,
+        call.target_address,
+        new Fr(call.is_public),
+      ]),
+      this.#nonce,
+    ];
+  }
+
+  /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */
+  hash() {
+    return pedersenHash(this.toFields(), this.#generatorIndex);
+  }
+
+  /**
+   * Creates an execution payload from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @returns The execution payload
+   */
+  static fromFunctionCalls(functionCalls: FunctionCall[]) {
+    return new EntrypointPayload(functionCalls, 0);
+  }
+
+  /**
+   * Creates an execution payload for the app-portion of a transaction from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @returns The execution payload
+   */
+  static fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>) {
+    if (functionCalls.length > APP_MAX_CALLS) {
+      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
+    }
+    const paddedCalls = padArrayEnd(functionCalls, emptyFunctionCall(), APP_MAX_CALLS);
+    return new EntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD);
+  }
+
+  /**
+   * Creates an execution payload to pay the fee for a transaction
+   * @param feeOpts - The fee payment options
+   * @returns The execution payload
+   */
+  static async fromFeeOptions(feeOpts?: FeeOptions) {
+    const calls = feeOpts ? await feeOpts.paymentMethod.getFunctionCalls(feeOpts?.gasSettings) : [];
+    const paddedCalls = padArrayEnd(calls, emptyFunctionCall(), FEE_MAX_CALLS);
+    return new EntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD);
+  }
+}

package/src/fee/fee_payment_method.ts

@@ -1,6 +1,6 @@
 import { type FunctionCall } from '@aztec/circuit-types';
+import { type GasSettings } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
 
 /**
  * Holds information about how the fee for a transaction is to be paid.
@@ -17,9 +17,8 @@ export interface FeePaymentMethod {
 
   /**
    * Creates a function call to pay the fee in the given asset.
-   * TODO(fees) replace maxFee with gas limits
-   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @param gasSettings - The gas limits and max fees.
    * @returns The function call to pay the fee.
    */
-  getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]>;
+  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]>;
 }

package/src/fee/native_fee_payment_method.ts

@@ -1,7 +1,6 @@
 import { type FunctionCall } from '@aztec/circuit-types';
-import { type AztecAddress, FunctionData } from '@aztec/circuits.js';
+import { type AztecAddress, FunctionData, type GasSettings } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
-import { type Fr } from '@aztec/foundation/fields';
 import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
 
 import { type Wallet } from '../account/wallet.js';
@@ -47,16 +46,16 @@ export class NativeFeePaymentMethod implements FeePaymentMethod {
   }
 
   /**
-   * Creates a function call to pay the fee in gas token..
-   * @param feeLimit - The maximum fee to be paid in gas token.
+   * Creates a function call to pay the fee in gas token.
+   * @param gasSettings - The gas settings.
    * @returns A function call
    */
-  getFunctionCalls(feeLimit: Fr): Promise<FunctionCall[]> {
+  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
     return Promise.resolve([
       {
         to: this.#gasTokenAddress,
         functionData: new FunctionData(FunctionSelector.fromSignature('pay_fee(Field)'), false),
-        args: [feeLimit],
+        args: [gasSettings.getFeeLimit()],
       },
     ]);
   }

package/src/fee/private_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { type FunctionCall } from '@aztec/circuit-types';
-import { FunctionData } from '@aztec/circuits.js';
+import { FunctionData, type GasSettings } from '@aztec/circuits.js';
 import { computeMessageSecretHash } from '@aztec/circuits.js/hash';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
@@ -53,11 +53,12 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
 
   /**
    * Creates a function call to pay the fee in the given asset.
-   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @param gasSettings - The gas settings.
    * @returns The function call to pay the fee.
    */
-  async getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
+  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
     const nonce = Fr.random();
+    const maxFee = gasSettings.getFeeLimit();
     const messageHash = computeAuthWitMessageHash(
       this.paymentContract,
       this.wallet.getChainId(),

package/src/fee/public_fee_payment_method.ts

@@ -1,5 +1,5 @@
 import { type FunctionCall } from '@aztec/circuit-types';
-import { FunctionData } from '@aztec/circuits.js';
+import { FunctionData, type GasSettings } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -46,12 +46,12 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
 
   /**
    * Creates a function call to pay the fee in the given asset.
-   * @param maxFee - The maximum fee to be paid in the given asset.
+   * @param gasSettings - The gas settings.
    * @returns The function call to pay the fee.
    */
-  getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
+  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
     const nonce = Fr.random();
-
+    const maxFee = gasSettings.getFeeLimit();
     const messageHash = computeAuthWitMessageHash(
       this.paymentContract,
       this.wallet.getChainId(),

package/src/index.ts

@@ -85,7 +85,7 @@ export {
   Body,
   CompleteAddress,
   ExtendedNote,
-  FunctionCall,
+  type FunctionCall,
   GrumpkinPrivateKey,
   L1ToL2Message,
   L1Actor,
@@ -100,7 +100,7 @@ export {
   MerkleTreeId,
   Note,
   PXE,
-  PackedArguments,
+  PackedValues,
   PartialAddress,
   PublicKey,
   SyncStatus,

package/src/utils/authwit.ts

@@ -1,4 +1,4 @@
-import { type FunctionCall, PackedArguments } from '@aztec/circuit-types';
+import { type FunctionCall, PackedValues } from '@aztec/circuit-types';
 import { type AztecAddress, type Fr, GeneratorIndex } from '@aztec/circuits.js';
 import { pedersenHash } from '@aztec/foundation/crypto';
 
@@ -25,7 +25,7 @@ export const computeAuthWitMessageHash = (caller: AztecAddress, chainId: Fr, ver
     computeInnerAuthWitHash([
       caller.toField(),
       action.functionData.selector.toField(),
-      PackedArguments.fromArgs(action.args).hash,
+      PackedValues.fromValues(action.args).hash,
     ]),
   );
 };

package/src/utils/cheat_codes.ts

@@ -1,7 +1,7 @@
 import { type Note, type PXE } from '@aztec/circuit-types';
 import { type AztecAddress, type EthAddress, Fr } from '@aztec/circuits.js';
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
-import { keccak, pedersenHash } from '@aztec/foundation/crypto';
+import { keccak256, pedersenHash } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import fs from 'fs';
@@ -167,7 +167,7 @@ export class EthCheatCodes {
   public keccak256(baseSlot: bigint, key: bigint): bigint {
     // abi encode (removing the 0x) - concat key and baseSlot (both padded to 32 bytes)
     const abiEncoded = toHex(key, true).substring(2) + toHex(baseSlot, true).substring(2);
-    return toBigIntBE(keccak(Buffer.from(abiEncoded, 'hex')));
+    return toBigIntBE(keccak256(Buffer.from(abiEncoded, 'hex')));
   }
 
   /**

package/src/wallet/account_wallet.ts

@@ -4,7 +4,7 @@ import { type ABIParameterVisibility, type FunctionAbi, FunctionType } from '@az
 
 import { type AccountInterface } from '../account/interface.js';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { type FeeOptions } from '../entrypoint/entrypoint.js';
+import { type ExecutionRequestInit } from '../entrypoint/entrypoint.js';
 import { computeAuthWitMessageHash } from '../utils/authwit.js';
 import { BaseWallet } from './base_wallet.js';
 
@@ -16,8 +16,8 @@ export class AccountWallet extends BaseWallet {
     super(pxe);
   }
 
-  createTxExecutionRequest(execs: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest> {
-    return this.account.createTxExecutionRequest(execs, fee);
+  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(exec);
   }
 
   getChainId(): Fr {

package/src/wallet/base_wallet.ts

@@ -28,7 +28,7 @@ import { type NodeInfo } from '@aztec/types/interfaces';
 
 import { type Wallet } from '../account/wallet.js';
 import { type ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import { type FeeOptions } from '../entrypoint/entrypoint.js';
+import { type ExecutionRequestInit } from '../entrypoint/entrypoint.js';
 
 /**
  * A base class for Wallet implementations
@@ -42,7 +42,7 @@ export abstract class BaseWallet implements Wallet {
 
   abstract getVersion(): Fr;
 
-  abstract createTxExecutionRequest(execs: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest>;
+  abstract createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest>;
 
   abstract createAuthWit(
     messageHashOrIntent: