@aztec/aztec.js 0.30.1 → 0.31.0

package/src/contract/base_contract_interaction.ts

@@ -1,6 +1,6 @@
 import { PXE, Tx, TxExecutionRequest } from '@aztec/circuit-types';
 
-import { FeeOptions } from '../account/interface.js';
+import { FeeOptions } from '../entrypoint/entrypoint.js';
 import { SentTx } from './sent_tx.js';
 
 /**

package/src/contract/checker.ts

@@ -25,7 +25,7 @@ export function abiChecker(artifact: ContractArtifact) {
     }
 
     // TODO: implement a better check for bytecode (right now only checks if it's > 0)
-    if (!('bytecode' in func && typeof func.bytecode === 'string' && func.bytecode.length > 0)) {
+    if (!('bytecode' in func && func.bytecode.length > 0)) {
       throw new Error('ABI function parameter has incorrect bytecode');
     }
 

package/src/contract/deploy_method.ts

@@ -5,7 +5,7 @@ import {
   getContractClassFromArtifact,
   getContractInstanceFromDeployParams,
 } from '@aztec/circuits.js';
-import { ContractArtifact, FunctionArtifact, getDefaultInitializer } from '@aztec/foundation/abi';
+import { ContractArtifact, FunctionArtifact, getInitializer } from '@aztec/foundation/abi';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -63,16 +63,10 @@ export class DeployMethod<TContract extends ContractBase = Contract> extends Bas
     private artifact: ContractArtifact,
     private postDeployCtor: (address: AztecAddress, wallet: Wallet) => Promise<TContract>,
     private args: any[] = [],
-    constructorName?: string,
+    constructorNameOrArtifact?: string | FunctionArtifact,
   ) {
     super(wallet);
-    this.constructorArtifact = constructorName
-      ? artifact.functions.find(f => f.name === constructorName)
-      : getDefaultInitializer(artifact);
-
-    if (constructorName && !this.constructorArtifact) {
-      throw new Error(`Constructor method ${constructorName} not found in contract artifact`);
-    }
+    this.constructorArtifact = getInitializer(artifact, constructorNameOrArtifact);
   }
 
   /**

package/src/contract/sent_tx.ts

@@ -15,6 +15,8 @@ export type WaitOpts = {
   waitForNotesSync?: boolean;
   /** Whether to include information useful for debugging/testing in the receipt. */
   debug?: boolean;
+  /** Whether to accept a revert as a status code for the tx when waiting for it. If false, will throw if the tx reverts. */
+  dontThrowOnRevert?: boolean;
 };
 
 export const DefaultWaitOpts: WaitOpts = {
@@ -60,10 +62,10 @@ export class SentTx {
    */
   public async wait(opts?: WaitOpts): Promise<FieldsOf<TxReceipt>> {
     if (opts?.debug && opts.waitForNotesSync === false) {
-      throw new Error('Cannot set getNotes to true if waitForNotesSync is false');
+      throw new Error('Cannot set debug to true if waitForNotesSync is false');
     }
     const receipt = await this.waitForReceipt(opts);
-    if (receipt.status !== TxStatus.MINED) {
+    if (!(receipt.status === TxStatus.MINED || (receipt.status === TxStatus.REVERTED && opts?.dontThrowOnRevert))) {
       throw new Error(
         `Transaction ${await this.getTxHash()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`,
       );

package/src/deployment/broadcast_function.ts

@@ -1,11 +1,9 @@
 import {
   ARTIFACT_FUNCTION_TREE_MAX_HEIGHT,
   MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  computeArtifactFunctionTree,
-  computeArtifactFunctionTreeRoot,
-  computeArtifactMetadataHash,
-  computeFunctionArtifactHash,
-  computePrivateFunctionsTree,
+  computeVerificationKeyHash,
+  createPrivateFunctionMembershipProof,
+  createUnconstrainedFunctionMembershipProof,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { ContractArtifact, FunctionSelector, FunctionType, bufferAsFields } from '@aztec/foundation/abi';
@@ -31,42 +29,38 @@ export function broadcastPrivateFunction(
   selector: FunctionSelector,
 ): ContractFunctionInteraction {
   const contractClass = getContractClassFromArtifact(artifact);
-  const privateFunction = contractClass.privateFunctions.find(fn => fn.selector.equals(selector));
-  if (!privateFunction) {
+  const privateFunctionArtifact = artifact.functions.find(fn => selector.equals(fn));
+  if (!privateFunctionArtifact) {
     throw new Error(`Private function with selector ${selector.toString()} not found`);
   }
-  const privateFunctionArtifact = artifact.functions.find(fn =>
-    FunctionSelector.fromNameAndParameters(fn).equals(selector),
-  )!;
 
-  // TODO(@spalladino): The following is computing the unconstrained root hash twice.
-  // Feels like we need a nicer API for returning a hash along with all its preimages,
-  // since it's common to provide all hash preimages to a function that verifies them.
-  const artifactMetadataHash = computeArtifactMetadataHash(artifact);
-  const unconstrainedArtifactFunctionTreeRoot = computeArtifactFunctionTreeRoot(artifact, FunctionType.OPEN);
+  const {
+    artifactTreeSiblingPath,
+    artifactTreeLeafIndex,
+    artifactMetadataHash,
+    functionMetadataHash,
+    unconstrainedFunctionsArtifactTreeRoot,
+    privateFunctionTreeSiblingPath,
+    privateFunctionTreeLeafIndex,
+  } = createPrivateFunctionMembershipProof(selector, artifact);
 
-  // We need two sibling paths because private function information is split across two trees:
-  // The "private function tree" captures the selectors and verification keys, and is used in the kernel circuit for verifying the proof generated by the app circuit.
-  // The "artifact tree" captures function bytecode and metadata, and is used by the pxe to check that its executing the code it's supposed to be executing, but it never goes into circuits.
-  const privateFunctionTreePath = computePrivateFunctionsTree(contractClass.privateFunctions).getSiblingPath(0);
-  const artifactFunctionTreePath = computeArtifactFunctionTree(artifact, FunctionType.SECRET)!.getSiblingPath(0);
-
-  const vkHash = privateFunction.vkHash;
-  const metadataHash = computeFunctionArtifactHash(privateFunctionArtifact);
+  const vkHash = computeVerificationKeyHash(privateFunctionArtifact.verificationKey!);
   const bytecode = bufferAsFields(
-    Buffer.from(privateFunctionArtifact.bytecode, 'hex'),
+    privateFunctionArtifact.bytecode,
     MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
   );
 
   const registerer = getRegistererContract(wallet);
   return registerer.methods.broadcast_private_function(
     contractClass.id,
-    Fr.fromBufferReduce(artifactMetadataHash),
-    Fr.fromBufferReduce(unconstrainedArtifactFunctionTreeRoot),
-    privateFunctionTreePath.map(Fr.fromBufferReduce),
-    padArrayEnd(artifactFunctionTreePath.map(Fr.fromBufferReduce), Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    artifactMetadataHash,
+    unconstrainedFunctionsArtifactTreeRoot,
+    privateFunctionTreeSiblingPath,
+    privateFunctionTreeLeafIndex,
+    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    artifactTreeLeafIndex,
     // eslint-disable-next-line camelcase
-    { selector, metadata_hash: Fr.fromBufferReduce(metadataHash), bytecode, vk_hash: vkHash },
+    { selector, metadata_hash: functionMetadataHash, bytecode, vk_hash: vkHash },
   );
 }
 
@@ -84,35 +78,33 @@ export function broadcastUnconstrainedFunction(
   artifact: ContractArtifact,
   selector: FunctionSelector,
 ): ContractFunctionInteraction {
+  const contractClass = getContractClassFromArtifact(artifact);
   const functionArtifactIndex = artifact.functions.findIndex(
-    fn => fn.functionType === FunctionType.UNCONSTRAINED && FunctionSelector.fromNameAndParameters(fn).equals(selector),
+    fn => fn.functionType === FunctionType.UNCONSTRAINED && selector.equals(fn),
   );
   if (functionArtifactIndex < 0) {
     throw new Error(`Unconstrained function with selector ${selector.toString()} not found`);
   }
   const functionArtifact = artifact.functions[functionArtifactIndex];
 
-  // TODO(@spalladino): Same comment as above on computing duplicated hashes.
-  const artifactMetadataHash = computeArtifactMetadataHash(artifact);
-  const privateArtifactFunctionTreeRoot = computeArtifactFunctionTreeRoot(artifact, FunctionType.SECRET);
-  const functionTreePath = computeArtifactFunctionTree(artifact, FunctionType.UNCONSTRAINED)!.getSiblingPath(
-    functionArtifactIndex,
-  );
+  const {
+    artifactMetadataHash,
+    artifactTreeLeafIndex,
+    artifactTreeSiblingPath,
+    functionMetadataHash,
+    privateFunctionsArtifactTreeRoot,
+  } = createUnconstrainedFunctionMembershipProof(selector, artifact);
 
-  const contractClassId = getContractClassFromArtifact(artifact).id;
-  const metadataHash = computeFunctionArtifactHash(functionArtifact);
-  const bytecode = bufferAsFields(
-    Buffer.from(functionArtifact.bytecode, 'hex'),
-    MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS,
-  );
+  const bytecode = bufferAsFields(functionArtifact.bytecode, MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS);
 
   const registerer = getRegistererContract(wallet);
   return registerer.methods.broadcast_unconstrained_function(
-    contractClassId,
-    Fr.fromBufferReduce(artifactMetadataHash),
-    Fr.fromBufferReduce(privateArtifactFunctionTreeRoot),
-    padArrayEnd(functionTreePath.map(Fr.fromBufferReduce), Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    contractClass.id,
+    artifactMetadataHash,
+    privateFunctionsArtifactTreeRoot,
+    padArrayEnd(artifactTreeSiblingPath, Fr.ZERO, ARTIFACT_FUNCTION_TREE_MAX_HEIGHT),
+    artifactTreeLeafIndex,
     // eslint-disable-next-line camelcase
-    { selector, metadata_hash: Fr.fromBufferReduce(metadataHash), bytecode },
+    { selector, metadata_hash: functionMetadataHash, bytecode },
   );
 }

package/src/entrypoint/default_entrypoint.ts

@@ -0,0 +1,27 @@
+import { FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
+import { TxContext } from '@aztec/circuits.js';
+
+import { EntrypointInterface } from './entrypoint.js';
+
+/**
+ * Default implementation of the entrypoint interface. It calls a function on a contract directly
+ */
+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);
+    const txContext = TxContext.empty(this.chainId, this.protocolVersion);
+    return Promise.resolve(
+      new TxExecutionRequest(
+        execution.to,
+        execution.functionData,
+        packedArguments.hash,
+        txContext,
+        [packedArguments],
+        [],
+      ),
+    );
+  }
+}

package/src/entrypoint/entrypoint.ts

@@ -0,0 +1,25 @@
+import { FunctionCall, TxExecutionRequest } from '@aztec/circuit-types';
+import { Fr } from '@aztec/foundation/fields';
+
+import { 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 fee limit to pay */
+  maxFee: bigint | number | Fr;
+};
+
+/** 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.
+   * @returns The authenticated transaction execution request.
+   */
+  createTxExecutionRequest(executions: FunctionCall[], feeOpts?: FeeOptions): Promise<TxExecutionRequest>;
+}

package/src/fee/private_fee_payment_method.ts

@@ -58,11 +58,16 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
    */
   async getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
     const nonce = Fr.random();
-    const messageHash = computeAuthWitMessageHash(this.paymentContract, {
-      args: [this.wallet.getCompleteAddress().address, this.paymentContract, maxFee, nonce],
-      functionData: new FunctionData(FunctionSelector.fromSignature('unshield((Field),(Field),Field,Field)'), true),
-      to: this.asset,
-    });
+    const messageHash = computeAuthWitMessageHash(
+      this.paymentContract,
+      this.wallet.getChainId(),
+      this.wallet.getVersion(),
+      {
+        args: [this.wallet.getCompleteAddress().address, this.paymentContract, maxFee, nonce],
+        functionData: new FunctionData(FunctionSelector.fromSignature('unshield((Field),(Field),Field,Field)'), true),
+        to: this.asset,
+      },
+    );
     await this.wallet.createAuthWit(messageHash);
 
     const secretHashForRebate = computeMessageSecretHash(this.rebateSecret);

package/src/fee/public_fee_payment_method.ts

@@ -51,14 +51,20 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
    */
   getFunctionCalls(maxFee: Fr): Promise<FunctionCall[]> {
     const nonce = Fr.random();
-    const messageHash = computeAuthWitMessageHash(this.paymentContract, {
-      args: [this.wallet.getAddress(), this.paymentContract, maxFee, nonce],
-      functionData: new FunctionData(
-        FunctionSelector.fromSignature('transfer_public((Field),(Field),Field,Field)'),
-        false,
-      ),
-      to: this.asset,
-    });
+
+    const messageHash = computeAuthWitMessageHash(
+      this.paymentContract,
+      this.wallet.getChainId(),
+      this.wallet.getVersion(),
+      {
+        args: [this.wallet.getAddress(), this.paymentContract, maxFee, nonce],
+        functionData: new FunctionData(
+          FunctionSelector.fromSignature('transfer_public((Field),(Field),Field,Field)'),
+          false,
+        ),
+        to: this.asset,
+      },
+    );
 
     return Promise.resolve([
       this.wallet.setPublicAuthWit(messageHash, true).request(),

package/src/utils/authwit.ts

@@ -5,19 +5,23 @@ import { pedersenHash } from '@aztec/foundation/crypto';
 // docs:start:authwit_computeAuthWitMessageHash
 /**
  * Compute an authentication witness message hash from a caller and a request
- * H(target: AztecAddress, H(caller: AztecAddress, selector: Field, args_hash: Field))
+ * H(target: AztecAddress, chainId: Field, version: Field, H(caller: AztecAddress, selector: Field, args_hash: Field))
  * Example usage would be `bob` authenticating `alice` to perform a transfer of `10`
  * tokens from his account to herself:
- * H(token, H(alice, transfer_selector, H(bob, alice, 10, nonce)))
+ * H(token, 1, 1, H(alice, transfer_selector, H(bob, alice, 10, nonce)))
  * `bob` then signs the message hash and gives it to `alice` who can then perform the
  * action.
  * @param caller - The caller approved to make the call
+ * @param chainId - The chain id for the message
+ * @param version - The version for the message
  * @param action - The request to be made (function call)
  * @returns The message hash for the witness
  */
-export const computeAuthWitMessageHash = (caller: AztecAddress, action: FunctionCall) => {
+export const computeAuthWitMessageHash = (caller: AztecAddress, chainId: Fr, version: Fr, action: FunctionCall) => {
   return computeOuterAuthWitHash(
     action.to.toField(),
+    chainId,
+    version,
     computeInnerAuthWitHash([
       caller.toField(),
       action.functionData.selector.toField(),
@@ -51,12 +55,14 @@ export const computeInnerAuthWitHash = (args: Fr[]) => {
  * It is used as part of the `computeAuthWitMessageHash` but can also be used
  * in case the message is not a "call" to a function, but arbitrary data.
  * @param consumer - The address that can "consume" the authwit
+ * @param chainId - The chain id that can "consume" the authwit
+ * @param version - The version that can "consume" the authwit
  * @param innerHash - The inner hash for the witness
  * @returns The outer hash for the witness
  */
-export const computeOuterAuthWitHash = (consumer: AztecAddress, innerHash: Fr) => {
+export const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
   return pedersenHash(
-    [consumer.toField(), innerHash].map(fr => fr.toBuffer()),
+    [consumer.toField(), chainId, version, innerHash].map(fr => fr.toBuffer()),
     GeneratorIndex.AUTHWIT_OUTER,
   );
 };

package/src/wallet/account_wallet.ts

@@ -2,8 +2,9 @@ import { AuthWitness, FunctionCall, PXE, TxExecutionRequest } from '@aztec/circu
 import { AztecAddress, Fr } from '@aztec/circuits.js';
 import { ABIParameterVisibility, FunctionAbi, FunctionType } from '@aztec/foundation/abi';
 
-import { AccountInterface, FeeOptions } from '../account/interface.js';
+import { AccountInterface } from '../account/interface.js';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { FeeOptions } from '../entrypoint/entrypoint.js';
 import { computeAuthWitMessageHash } from '../utils/authwit.js';
 import { BaseWallet } from './base_wallet.js';
 
@@ -19,6 +20,14 @@ export class AccountWallet extends BaseWallet {
     return this.account.createTxExecutionRequest(execs, fee);
   }
 
+  getChainId(): Fr {
+    return this.account.getChainId();
+  }
+
+  getVersion(): Fr {
+    return this.account.getVersion();
+  }
+
   /**
    * Computes an authentication witness from either a message or a caller and an action.
    * If a message is provided, it will create a witness for the message directly.
@@ -35,6 +44,10 @@ export class AccountWallet extends BaseWallet {
           caller: AztecAddress;
           /** The action to approve */
           action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
         },
   ): Promise<AuthWitness> {
     const messageHash = this.getMessageHash(messageHashOrIntent);
@@ -43,6 +56,37 @@ export class AccountWallet extends BaseWallet {
     return witness;
   }
 
+  /**
+   * Returns a function interaction to set a message hash as authorized or revoked in this account.
+   * Public calls can then consume this authorization.
+   * @param messageHashOrIntent - The message or the caller and action to authorize/revoke
+   * @param authorized - True to authorize, false to revoke authorization.
+   * @returns - A function interaction.
+   */
+  public setPublicAuthWit(
+    messageHashOrIntent:
+      | Fr
+      | Buffer
+      | {
+          /** The caller to approve  */
+          caller: AztecAddress;
+          /** The action to approve */
+          action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
+        },
+    authorized: boolean,
+  ): ContractFunctionInteraction {
+    const message = this.getMessageHash(messageHashOrIntent);
+    if (authorized) {
+      return new ContractFunctionInteraction(this, this.getAddress(), this.getApprovePublicAuthwitAbi(), [message]);
+    } else {
+      return this.cancelAuthWit(message);
+    }
+  }
+
   /**
    * Returns the message hash for the given message or authwit input.
    * @param messageHashOrIntent - The message hash or the caller and action to authorize
@@ -57,26 +101,37 @@ export class AccountWallet extends BaseWallet {
           caller: AztecAddress;
           /** The action to approve */
           action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
         },
   ): Fr {
     if (Buffer.isBuffer(messageHashOrIntent)) {
       return Fr.fromBuffer(messageHashOrIntent);
     } else if (messageHashOrIntent instanceof Fr) {
       return messageHashOrIntent;
-    } else if (messageHashOrIntent.action instanceof ContractFunctionInteraction) {
-      return computeAuthWitMessageHash(messageHashOrIntent.caller, messageHashOrIntent.action.request());
+    } else {
+      return computeAuthWitMessageHash(
+        messageHashOrIntent.caller,
+        messageHashOrIntent.chainId || this.getChainId(),
+        messageHashOrIntent.version || this.getVersion(),
+        messageHashOrIntent.action instanceof ContractFunctionInteraction
+          ? messageHashOrIntent.action.request()
+          : messageHashOrIntent.action,
+      );
     }
-    return computeAuthWitMessageHash(messageHashOrIntent.caller, messageHashOrIntent.action);
   }
 
   /**
-   * Returns a function interaction to set a message hash as authorized or revoked in this account.
-   * Public calls can then consume this authorization.
-   * @param messageHashOrIntent - The message or the caller and action to authorize/revoke
-   * @param authorized - True to authorize, false to revoke authorization.
-   * @returns - A function interaction.
+   * Lookup the validity of an authwit in private and public contexts.
+   * If the authwit have been consumed already (nullifier spent), will return false in both contexts.
+   * @param target - The target contract address
+   * @param messageHashOrIntent - The message hash or the caller and action to authorize/revoke
+   * @returns - A struct containing the validity of the authwit in private and public contexts.
    */
-  public setPublicAuthWit(
+  async lookupValidity(
+    target: AztecAddress,
     messageHashOrIntent:
       | Fr
       | Buffer
@@ -85,15 +140,29 @@ export class AccountWallet extends BaseWallet {
           caller: AztecAddress;
           /** The action to approve */
           action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
         },
-    authorized: boolean,
-  ): ContractFunctionInteraction {
-    const message = this.getMessageHash(messageHashOrIntent);
-    if (authorized) {
-      return new ContractFunctionInteraction(this, this.getAddress(), this.getApprovePublicAuthwitAbi(), [message]);
-    } else {
-      return this.cancelAuthWit(message);
-    }
+  ): Promise<{
+    /** boolean flag indicating if the authwit is valid in private context */
+    isValidInPrivate: boolean;
+    /** boolean flag indicating if the authwit is valid in public context */
+    isValidInPublic: boolean;
+  }> {
+    const messageHash = this.getMessageHash(messageHashOrIntent);
+    const witness = await this.getAuthWitness(messageHash);
+    const blockNumber = await this.getBlockNumber();
+    const interaction = new ContractFunctionInteraction(this, target, this.getLookupValidityAbi(), [
+      target,
+      blockNumber,
+      witness != undefined,
+      messageHash,
+    ]);
+
+    const [isValidInPrivate, isValidInPublic] = await interaction.view();
+    return { isValidInPrivate, isValidInPublic };
   }
 
   /**
@@ -110,6 +179,10 @@ export class AccountWallet extends BaseWallet {
           caller: AztecAddress;
           /** The action to approve */
           action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
         },
   ): ContractFunctionInteraction {
     const message = this.getMessageHash(messageHashOrIntent);
@@ -160,4 +233,36 @@ export class AccountWallet extends BaseWallet {
       returnTypes: [],
     };
   }
+
+  private getLookupValidityAbi(): FunctionAbi {
+    return {
+      name: 'lookup_validity',
+      isInitializer: false,
+      functionType: FunctionType.UNCONSTRAINED,
+      isInternal: false,
+      parameters: [
+        {
+          name: 'myself',
+          type: {
+            kind: 'struct',
+            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+            fields: [{ name: 'inner', type: { kind: 'field' } }],
+          },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        {
+          name: 'block_number',
+          type: { kind: 'integer', sign: 'unsigned', width: 32 },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        {
+          name: 'check_private',
+          type: { kind: 'boolean' },
+          visibility: 'private' as ABIParameterVisibility,
+        },
+        { name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
+      ],
+      returnTypes: [{ kind: 'array', length: 2, type: { kind: 'boolean' } }],
+    };
+  }
 }

package/src/wallet/base_wallet.ts

@@ -19,9 +19,9 @@ import { ContractArtifact } from '@aztec/foundation/abi';
 import { ContractClassWithId, ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { NodeInfo } from '@aztec/types/interfaces';
 
-import { FeeOptions } from '../account/interface.js';
 import { Wallet } from '../account/wallet.js';
 import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { FeeOptions } from '../entrypoint/entrypoint.js';
 
 /**
  * A base class for Wallet implementations
@@ -31,6 +31,10 @@ export abstract class BaseWallet implements Wallet {
 
   abstract getCompleteAddress(): CompleteAddress;
 
+  abstract getChainId(): Fr;
+
+  abstract getVersion(): Fr;
+
   abstract createTxExecutionRequest(execs: FunctionCall[], fee?: FeeOptions): Promise<TxExecutionRequest>;
 
   abstract createAuthWit(
@@ -42,6 +46,10 @@ export abstract class BaseWallet implements Wallet {
           caller: AztecAddress;
           /** The action to approve */
           action: ContractFunctionInteraction | FunctionCall;
+          /** The chain id to approve */
+          chainId?: Fr;
+          /** The version to approve  */
+          version?: Fr;
         },
   ): Promise<AuthWitness>;
 
@@ -139,6 +147,9 @@ export abstract class BaseWallet implements Wallet {
   addAuthWitness(authWitness: AuthWitness) {
     return this.pxe.addAuthWitness(authWitness);
   }
+  getAuthWitness(messageHash: Fr) {
+    return this.pxe.getAuthWitness(messageHash);
+  }
   isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return this.pxe.isContractClassPubliclyRegistered(id);
   }

package/src/wallet/signerless_wallet.ts

@@ -1,37 +1,41 @@
-import { AuthWitness, FunctionCall, PackedArguments, TxExecutionRequest } from '@aztec/circuit-types';
-import { CompleteAddress, Fr, TxContext } from '@aztec/circuits.js';
+import { AuthWitness, FunctionCall, PXE, TxExecutionRequest } from '@aztec/circuit-types';
+import { CompleteAddress, Fr } from '@aztec/circuits.js';
 
+import { DefaultEntrypoint } from '../entrypoint/default_entrypoint.js';
+import { EntrypointInterface } from '../entrypoint/entrypoint.js';
 import { BaseWallet } from './base_wallet.js';
 
 /**
  * Wallet implementation which creates a transaction request directly to the requested contract without any signing.
  */
 export class SignerlessWallet extends BaseWallet {
+  constructor(pxe: PXE, private entrypoint?: EntrypointInterface) {
+    super(pxe);
+  }
+
   async createTxExecutionRequest(executions: FunctionCall[]): Promise<TxExecutionRequest> {
-    if (executions.length !== 1) {
-      throw new Error(`Unexpected number of executions. Expected 1 but received ${executions.length}.`);
+    let entrypoint = this.entrypoint;
+    if (!entrypoint) {
+      const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
+      entrypoint = new DefaultEntrypoint(chainId, protocolVersion);
     }
-    const [execution] = executions;
-    const packedArguments = PackedArguments.fromArgs(execution.args);
-    const { chainId, protocolVersion } = await this.pxe.getNodeInfo();
-    const txContext = TxContext.empty(chainId, protocolVersion);
-    return Promise.resolve(
-      new TxExecutionRequest(
-        execution.to,
-        execution.functionData,
-        packedArguments.hash,
-        txContext,
-        [packedArguments],
-        [],
-      ),
-    );
+
+    return entrypoint.createTxExecutionRequest(executions);
+  }
+
+  getChainId(): Fr {
+    throw new Error('Method not implemented.');
+  }
+
+  getVersion(): Fr {
+    throw new Error('Method not implemented.');
   }
 
   getCompleteAddress(): CompleteAddress {
     throw new Error('Method not implemented.');
   }
 
-  createAuthWit(_message: Fr): Promise<AuthWitness> {
+  createAuthWit(_messageHash: Fr): Promise<AuthWitness> {
     throw new Error('Method not implemented.');
   }
 }