feat!: slimmer wallet interface (#17136)

Keep removing methods that do not belong in the wallet interface. This
time:

- `createPublicAuthwit`: This is just a contract interaction. A few
convenience methods have been added, and the `TestWallet` keeps the
interface to avoid pain the e2e tests, but from now on public authwits
are just that: glorified ContractInteractions
- `getPublicEvents`: Nuked also from PXE. There's 0 private information
required to decode them, moved to an utility instead

`createAuthwit` in the Wallet loses the ability to compute them from
`ContractFunctionInteraction`s since they're not serializable (still
kept it in `TestWallet` for the same reasons as above)

Added a new `getChainInfo` method that returns chainId and version and
can be used to generate authwits externally and generally to gather
information about the chain the wallet is connected to.

Also added a proper validated interface to the `Wallet` that will be
used soon ™️

Author: AztecBot

playground/src/components/contract/components/CreateAuthwitDialog.tsx

@@ -1,6 +1,14 @@
 import DialogTitle from '@mui/material/DialogTitle';
 import Dialog from '@mui/material/Dialog';
-import { AztecAddress, Contract, ContractFunctionInteraction, type SendMethodOptions } from '@aztec/aztec.js';
+import {
+  AztecAddress,
+  computeAuthWitMessageHash,
+  Contract,
+  ContractFunctionInteraction,
+  Fr,
+  SetPublicAuthwitContractInteraction,
+  type SendMethodOptions,
+} from '@aztec/aztec.js';
 import Button from '@mui/material/Button';
 import CircularProgress from '@mui/material/CircularProgress';
 import FormControl from '@mui/material/FormControl';
@@ -49,30 +57,27 @@ export function CreateAuthwitDialog({ open, contract, fnName, args, isPrivate, o
 
   const [feePaymentMethod, setFeePaymentMethod] = useState(null);
 
-  const { wallet, playgroundDB, from } = useContext(AztecContext);
+  const { wallet, node, playgroundDB, from } = useContext(AztecContext);
 
   const handleClose = () => {
     onClose();
   };
 
   const createAuthwit = async () => {
     setCreating(true);
+    const call = await contract.methods[fnName](...args).getFunctionCall();
+    const intent = {
+      caller: AztecAddress.fromString(caller),
+      call,
+    };
     try {
-      const action = contract.methods[fnName](...args);
       let witness;
       if (isPrivate) {
-        witness = await wallet.createAuthWit(from, {
-          caller: AztecAddress.fromString(caller),
-          action,
-        });
+        witness = await wallet.createAuthWit(from, intent);
         await playgroundDB.storeAuthwitness(witness, undefined, alias);
         onClose();
       } else {
-        const validateActionInteraction = await wallet.setPublicAuthWit(
-          from,
-          { caller: AztecAddress.fromString(caller), action },
-          true,
-        );
+        const validateActionInteraction = await SetPublicAuthwitContractInteraction.create(wallet, from, intent, true);
         const opts: SendMethodOptions = { from, fee: { paymentMethod: feePaymentMethod } };
         onClose(true, validateActionInteraction, opts);
       }

playground/src/wallet/extension_wallet.ts

@@ -0,0 +1,58 @@
+import { type Wallet, WalletSchema } from '@aztec/aztec.js/wallet';
+import { promiseWithResolvers, type PromiseWithResolvers } from '@aztec/foundation/promise';
+import { schemaHasMethod } from '@aztec/foundation/schemas';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+
+type FunctionsOf<T> = { [K in keyof T as T[K] extends Function ? K : never]: T[K] };
+
+export class ExtensionWallet {
+  private inFlight = new Map<string, PromiseWithResolvers<any>>();
+
+  private constructor() {}
+
+  static create() {
+    const wallet = new ExtensionWallet();
+    window.addEventListener('message', async event => {
+      if (event.source !== window) return;
+
+      const { messageId, response } = event.data;
+      if (!response) {
+        return;
+      }
+      const { resolve, reject } = wallet.inFlight.get(messageId);
+      if (!resolve || !reject) {
+        console.error('No in-flight message for id', messageId);
+        return;
+      }
+      const { value, error } = response;
+      if (error) {
+        reject(new Error(error));
+      } else {
+        resolve(value);
+      }
+      wallet.inFlight.delete(messageId);
+    });
+    return new Proxy(wallet, {
+      get: (target, prop) => {
+        if (schemaHasMethod(WalletSchema, prop.toString())) {
+          return async (...args: any[]) => {
+            return await target.postMessage({
+              type: prop.toString() as keyof FunctionsOf<Wallet>,
+              args,
+            });
+          };
+        } else {
+          return target[prop];
+        }
+      },
+    }) as unknown as Wallet;
+  }
+
+  private async postMessage({ type, args }: { type: keyof FunctionsOf<Wallet>; args: any[] }) {
+    const messageId = globalThis.crypto.randomUUID();
+    window.postMessage(jsonStringify({ type, args, messageId }), '*');
+    const { promise, resolve, reject } = promiseWithResolvers<any>();
+    this.inFlight.set(messageId, { promise, resolve, reject });
+    return promise;
+  }
+}

yarn-project/aztec.js/package.json

@@ -90,7 +90,8 @@
     "@aztec/stdlib": "workspace:^",
     "axios": "^1.8.2",
     "tslib": "^2.4.0",
-    "viem": "2.23.7"
+    "viem": "2.23.7",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",

yarn-project/aztec.js/src/account/account.ts

@@ -1,20 +1,10 @@
 import type { FeeOptions, TxExecutionOptions } from '@aztec/entrypoints/interfaces';
 import type { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { Fr } from '@aztec/foundation/fields';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { ABIParameterVisibility, type FunctionAbi, FunctionType } from '@aztec/stdlib/abi';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import {
-  type IntentAction,
-  type IntentInnerHash,
-  computeAuthWitMessageHash,
-  computeInnerAuthWitHashFromAction,
-} from '../utils/authwit.js';
-import type { Wallet } from '../wallet/wallet.js';
+import { type CallIntent, type IntentInnerHash, computeAuthWitMessageHash } from '../utils/authwit.js';
 import type { AccountInterface } from './interface.js';
 
 /**
@@ -27,18 +17,7 @@ interface AuthwitnessIntentProvider {
    * during function execution
    * @param intent - The action (or inner hash) to authorize
    */
-  createAuthWit(intent: IntentInnerHash | IntentAction | Buffer | Fr): Promise<AuthWitness>;
-  /**
-   * Sets a public authwit for an intent or inner hash
-   * @param wallet - The wallet to send the transaction authorizing the action from
-   * @param messageHashOrIntent - The action (or inner hash) to authorize/deny
-   * @param authorized - Whether to authorize or deny the action
-   */
-  setPublicAuthWit(
-    wallet: Wallet,
-    messageHashOrIntent: Fr | Buffer | IntentInnerHash | IntentAction,
-    authorized: boolean,
-  ): Promise<ContractFunctionInteraction>;
+  createAuthWit(intent: IntentInnerHash | CallIntent | Buffer | Fr): Promise<AuthWitness>;
 }
 
 /**
@@ -90,7 +69,7 @@ export class BaseAccount implements Account {
    * @param messageHashOrIntent - The message hash of the intent to approve
    * @returns The authentication witness
    */
-  async createAuthWit(messageHashOrIntent: Fr | Buffer | IntentAction | IntentInnerHash): Promise<AuthWitness> {
+  async createAuthWit(messageHashOrIntent: Fr | Buffer | CallIntent | IntentInnerHash): Promise<AuthWitness> {
     let messageHash: Fr;
     if (Buffer.isBuffer(messageHashOrIntent)) {
       messageHash = Fr.fromBuffer(messageHashOrIntent);
@@ -103,175 +82,15 @@ export class BaseAccount implements Account {
     return this.account.createAuthWit(messageHash);
   }
 
-  /**
-   * Returns a function interaction to set a message hash as authorized or revoked in this account.
-   *
-   * Public calls can then consume this authorization.
-   *
-   * @param wallet - The wallet to send the transaction authorizing the action from
-   * @param messageHashOrIntent - The message hash or intent to authorize/revoke
-   * @param authorized - True to authorize, false to revoke authorization.
-   * @returns - A function interaction.
-   */
-  public async setPublicAuthWit(
-    wallet: Wallet,
-    messageHashOrIntent: Fr | Buffer | IntentInnerHash | IntentAction,
-    authorized: boolean,
-  ): Promise<ContractFunctionInteraction> {
-    let messageHash: Fr;
-    if (Buffer.isBuffer(messageHashOrIntent)) {
-      messageHash = Fr.fromBuffer(messageHashOrIntent);
-    } else if (messageHashOrIntent instanceof Fr) {
-      messageHash = messageHashOrIntent;
-    } else {
-      messageHash = await this.getMessageHash(messageHashOrIntent);
-    }
-
-    return new ContractFunctionInteraction(wallet, ProtocolContractAddress.AuthRegistry, this.getSetAuthorizedAbi(), [
-      messageHash,
-      authorized,
-    ]);
-  }
-
-  private async getInnerHashAndConsumer(intent: IntentInnerHash | IntentAction): Promise<{
-    /** The inner hash */
-    innerHash: Fr;
-    /** The consumer of the authwit */
-    consumer: AztecAddress;
-  }> {
-    if ('caller' in intent && 'action' in intent) {
-      const action =
-        intent.action instanceof ContractFunctionInteraction ? (await intent.action.request()).calls[0] : intent.action;
-      return {
-        innerHash: await computeInnerAuthWitHashFromAction(intent.caller, action),
-        consumer: action.to,
-      };
-    } else if (Buffer.isBuffer(intent.innerHash)) {
-      return { innerHash: Fr.fromBuffer(intent.innerHash), consumer: intent.consumer };
-    }
-    return { innerHash: intent.innerHash, consumer: intent.consumer };
-  }
-
   /**
    * Returns the message hash for the given intent
    *
    * @param intent - A tuple of (consumer and inner hash) or (caller and action)
    * @returns The message hash
    */
-  private getMessageHash(intent: IntentInnerHash | IntentAction): Promise<Fr> {
+  private getMessageHash(intent: IntentInnerHash | CallIntent): Promise<Fr> {
     const chainId = this.getChainId();
     const version = this.getVersion();
     return computeAuthWitMessageHash(intent, { chainId, version });
   }
-
-  /**
-   * Lookup the validity of an authwit in private and public contexts.
-   *
-   * Uses the chain id and version of the wallet.
-   *
-   * @param wallet - The wallet use to simulate and read the public data
-   * @param onBehalfOf - The address of the "approver"
-   * @param intent - The consumer and inner hash or the caller and action to lookup
-   * @param witness - The computed authentication witness to check
-   * @returns - A struct containing the validity of the authwit in private and public contexts.
-   */
-  async lookupValidity(
-    wallet: Wallet,
-    onBehalfOf: AztecAddress,
-    intent: IntentInnerHash | IntentAction,
-    witness: AuthWitness,
-  ): 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 { innerHash, consumer } = await this.getInnerHashAndConsumer(intent);
-
-    const messageHash = await this.getMessageHash(intent);
-    const results = { isValidInPrivate: false, isValidInPublic: false };
-
-    // Check private
-    try {
-      results.isValidInPrivate = (await new ContractFunctionInteraction(
-        wallet,
-        onBehalfOf,
-        this.getLookupValidityAbi(),
-        [consumer, innerHash],
-      ).simulate({ from: this.getAddress(), authWitnesses: [witness] })) as boolean;
-      // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
-      // eslint-disable-next-line no-empty
-    } catch {}
-
-    // check public
-    results.isValidInPublic = (await new ContractFunctionInteraction(
-      wallet,
-      ProtocolContractAddress.AuthRegistry,
-      this.getIsConsumableAbi(),
-      [onBehalfOf, messageHash],
-    ).simulate({ from: this.getAddress() })) as boolean;
-
-    return results;
-  }
-
-  private getSetAuthorizedAbi(): FunctionAbi {
-    return {
-      name: 'set_authorized',
-      isInitializer: false,
-      functionType: FunctionType.PUBLIC,
-      isInternal: true,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'message_hash',
-          type: { kind: 'field' },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-        {
-          name: 'authorize',
-          type: { kind: 'boolean' },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-      ],
-      returnTypes: [],
-      errorTypes: {},
-    };
-  }
-
-  private getLookupValidityAbi(): FunctionAbi {
-    return {
-      name: 'lookup_validity',
-      isInitializer: false,
-      functionType: FunctionType.UTILITY,
-      isInternal: false,
-      isStatic: false,
-      parameters: [{ name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility }],
-      returnTypes: [{ kind: 'boolean' }],
-      errorTypes: {},
-    };
-  }
-
-  private getIsConsumableAbi(): FunctionAbi {
-    return {
-      name: 'utility_is_consumable',
-      isInitializer: false,
-      functionType: FunctionType.UTILITY,
-      isInternal: false,
-      isStatic: false,
-      parameters: [
-        {
-          name: 'address',
-          type: {
-            fields: [{ name: 'inner', type: { kind: 'field' } }],
-            kind: 'struct',
-            path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
-          },
-          visibility: 'private' as ABIParameterVisibility,
-        },
-        { name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility },
-      ],
-      returnTypes: [{ kind: 'boolean' }],
-      errorTypes: {},
-    };
-  }
 }

yarn-project/aztec.js/src/account/signerless_account.ts

@@ -7,7 +7,7 @@ import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import type { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
 import type { Wallet } from '../wallet/wallet.js';
 import type { Account } from './account.js';
 
@@ -45,13 +45,13 @@ export class SignerlessAccount implements Account {
     throw new Error('SignerlessAccount: Method getAddress not implemented.');
   }
 
-  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | IntentAction): Promise<AuthWitness> {
+  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
     throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
   }
 
   setPublicAuthWit(
     _wallet: Wallet,
-    _messageHashOrIntent: Fr | Buffer | IntentInnerHash | IntentAction,
+    _messageHashOrIntent: Fr | Buffer | IntentInnerHash | CallIntent,
     _authorized: boolean,
   ): Promise<ContractFunctionInteraction> {
     throw new Error('SignerlessAccount: Method setPublicAuthWit not implemented.');

yarn-project/aztec.js/src/api/authorization.ts

@@ -1,3 +1,14 @@
 export { AuthWitness } from '@aztec/stdlib/auth-witness';
+export {
+  SetPublicAuthwitContractInteraction,
+  type ContractFunctionInteractionCallIntent,
+  getMessageHashFromIntent,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHashFromAction,
+  lookupValidity,
+  type CallIntent,
+  type IntentInnerHash,
+} from '../utils/authwit.js';
+export { computeInnerAuthWitHash } from '@aztec/stdlib/auth-witness';
 
 export { CallAuthorizationRequest } from '../authorization/call_authorization_request.js';