@aztec/aztec.js 0.0.0-test.0

package/src/rpc_clients/node/index.ts

@@ -0,0 +1,77 @@
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { NoRetryError, makeBackoff, retry } from '@aztec/foundation/retry';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { ComponentsVersions } from '@aztec/stdlib/versioning';
+
+import { Axios, type AxiosError } from 'axios';
+import { inspect } from 'util';
+
+import { createPXEClient } from '../pxe_client.js';
+
+/**
+ * A fetch implementation using axios.
+ * @param host - The URL of the host.
+ * @param rpcMethod - The RPC method to call.
+ * @param body - The body of the request.
+ * @param useApiEndpoints - Whether to use the API endpoints or inject the method in the body.
+ * @returns The response data.
+ */
+async function axiosFetch(host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) {
+  const request = new Axios({
+    headers: { 'content-type': 'application/json' },
+    transformRequest: [(data: any) => jsonStringify(data)],
+    transformResponse: [(data: any) => JSON.parse(data)],
+  });
+  const [url, content] = useApiEndpoints ? [`${host}/${rpcMethod}`, body] : [host, { ...body, method: rpcMethod }];
+  const resp = await request.post(url, content).catch((error: AxiosError) => {
+    if (error.response) {
+      return error.response;
+    }
+    const errorMessage = `Error fetching from host ${host} with method ${rpcMethod}: ${inspect(error)}`;
+    throw new Error(errorMessage);
+  });
+
+  const isOK = resp.status >= 200 && resp.status < 300;
+  if (isOK) {
+    const headers = {
+      get: (header: string) =>
+        typeof resp.headers.get === 'function' ? resp.headers.get(header)?.toString() : undefined,
+    };
+    return { response: resp.data, headers };
+  } else {
+    const errorMessage = `Error ${resp.status} from json-rpc server ${host} on ${rpcMethod}: ${resp.data.error.message}`;
+    if (resp.status >= 400 && resp.status < 500) {
+      throw new NoRetryError(errorMessage);
+    } else {
+      throw new Error(errorMessage);
+    }
+  }
+}
+
+/**
+ * Creates a PXE client with a given set of retries on non-server errors.
+ * Checks that PXE matches the expected version, and warns if not.
+ * @param rpcUrl - URL of the RPC server wrapping the PXE.
+ * @param _logger - Debug logger to warn version incompatibilities.
+ * @returns A PXE client.
+ */
+export function createCompatibleClient(
+  rpcUrl: string,
+  logger: Logger = createLogger('aztecjs:pxe_client'),
+  versions: Partial<ComponentsVersions> = {},
+): Promise<PXE> {
+  // Use axios due to timeout issues with fetch when proving TXs.
+  const fetch = async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) => {
+    return await retry(
+      () => axiosFetch(host, rpcMethod, body, useApiEndpoints),
+      `JsonRpcClient request ${rpcMethod} to ${host}`,
+      makeBackoff([1, 2, 3]),
+      logger,
+      false,
+    );
+  };
+  const pxe = createPXEClient(rpcUrl, versions, fetch);
+
+  return Promise.resolve(pxe);
+}

package/src/rpc_clients/pxe_client.ts

@@ -0,0 +1,25 @@
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { type PXE, PXESchema } from '@aztec/stdlib/interfaces/client';
+import { type ComponentsVersions, getVersioningResponseHandler } from '@aztec/stdlib/versioning';
+
+/**
+ * Creates a JSON-RPC client to remotely talk to PXE.
+ * @param url - The URL of the PXE.
+ * @param fetch - The fetch implementation to use.
+ * @returns A JSON-RPC client of PXE.
+ */
+export function createPXEClient(
+  url: string,
+  versions: Partial<ComponentsVersions> = {},
+  fetch = makeFetch([1, 2, 3], false),
+): PXE {
+  return createSafeJsonRpcClient<PXE>(url, PXESchema, {
+    namespaceMethods: 'pxe',
+    fetch,
+    onResponse: getVersioningResponseHandler({
+      l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+      ...versions,
+    }),
+  });
+}

package/src/utils/abi_types.ts

@@ -0,0 +1,25 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Fr } from '@aztec/foundation/fields';
+import type { EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/** Any type that can be converted into a field for a contract call. */
+export type FieldLike = Fr | Buffer | bigint | number | { /** Converts to field */ toField: () => Fr };
+
+/** Any type that can be converted into an EthAddress Aztec.nr struct. */
+export type EthAddressLike = { /** Wrapped address */ address: FieldLike } | EthAddress;
+
+/** Any type that can be converted into an AztecAddress Aztec.nr struct. */
+export type AztecAddressLike = { /** Wrapped address */ address: FieldLike } | AztecAddress;
+
+/** Any type that can be converted into a FunctionSelector Aztec.nr struct. */
+export type FunctionSelectorLike = FieldLike | FunctionSelector;
+
+/** Any type that can be converted into an EventSelector Aztec.nr struct. */
+export type EventSelectorLike = FieldLike | EventSelector;
+
+/** Any type that can be converted into a U128. */
+export type U128Like = bigint | number;
+
+/** Any type that can be converted into a struct with a single `inner` field. */
+export type WrappedFieldLike = { /** Wrapped value */ inner: FieldLike } | FieldLike;

package/src/utils/authwit.ts

@@ -0,0 +1,110 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HashedValues } from '@aztec/stdlib/tx';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+
+/** Metadata for the intent */
+export type IntentMetadata = {
+  /** The chain id to approve */
+  chainId: Fr;
+  /** The version to approve  */
+  version: Fr;
+};
+
+/** Intent with an inner hash */
+export type IntentInnerHash = {
+  /** The consumer   */
+  consumer: AztecAddress;
+  /** The action to approve */
+  innerHash: Buffer | Fr;
+};
+
+/** Intent with an action */
+export type IntentAction = {
+  /** The caller to approve  */
+  caller: AztecAddress;
+  /** The action to approve */
+  action: ContractFunctionInteraction | FunctionCall;
+};
+
+// docs:start:authwit_computeAuthWitMessageHash
+/**
+ * Compute an authentication witness message hash from an intent and metadata
+ *
+ * If using the `IntentInnerHash`, the consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ * The `innerHash` itself will be the message that a contract is allowed to execute.
+ * At the point of "approval checking", the validating contract (account for private and registry for public) will be computing the message hash
+ * (`H(consumer, chainid, version, inner_hash)`) where the all but the `inner_hash` is injected from the context (consumer = msg_sender),
+ * and use it for the authentication check.
+ * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
+ *
+ * If using the `IntentAction`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
+ *
+ *
+ * @param intent - The intent to approve (consumer and innerHash or caller and action)
+ *                 The consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ *                 The caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ *                 The caller becomes part of the `inner_hash` and is dealt with entirely in application logic.
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the action
+ */
+export const computeAuthWitMessageHash = async (intent: IntentInnerHash | IntentAction, metadata: IntentMetadata) => {
+  const chainId = metadata.chainId;
+  const version = metadata.version;
+
+  if ('caller' in intent) {
+    const action = intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
+    return computeOuterAuthWitHash(
+      action.to,
+      chainId,
+      version,
+      await computeInnerAuthWitHashFromAction(intent.caller, action),
+    );
+  } else {
+    const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
+    return computeOuterAuthWitHash(intent.consumer, chainId, version, inner);
+  }
+};
+// docs:end:authwit_computeAuthWitMessageHash
+
+export const computeInnerAuthWitHashFromAction = async (caller: AztecAddress, action: FunctionCall) =>
+  computeInnerAuthWitHash([
+    caller.toField(),
+    action.selector.toField(),
+    (await HashedValues.fromValues(action.args)).hash,
+  ]);
+
+/**
+ * Compute the inner hash for an authentication witness.
+ * This is the "intent" of the message, before siloed with the consumer.
+ * 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 args - The arguments to hash
+ * @returns The inner hash for the witness
+ */
+export const computeInnerAuthWitHash = (args: Fr[]) => {
+  return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
+};
+
+/**
+ * Compute the outer hash for an authentication witness.
+ * This is the value siloed with its "consumer" and what the `on_behalf_of`
+ * should be signing.
+ * The consumer is who will be consuming the message, for token approvals it
+ * is the token contract itself (because the token makes the call to check the approval).
+ * 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
+ */
+const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
+  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
+};

package/src/utils/aztec_cheatcodes.ts

@@ -0,0 +1,77 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { Note } from '@aztec/stdlib/note';
+
+/**
+ * A class that provides utility functions for interacting with the aztec chain.
+ */
+export class AztecCheatCodes {
+  constructor(
+    /**
+     * The PXE Service to use for interacting with the chain
+     */
+    public pxe: PXE,
+    /**
+     * The logger to use for the aztec cheatcodes
+     */
+    public logger = createLogger('aztecjs:cheat_codes'),
+  ) {}
+
+  /**
+   * Computes the slot value for a given map and key.
+   * @param mapSlot - The slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */
+  public computeSlotInMap(mapSlot: Fr | bigint, key: Fr | bigint | AztecAddress): Promise<Fr> {
+    const keyFr = typeof key === 'bigint' ? new Fr(key) : key.toField();
+    return deriveStorageSlotInMap(mapSlot, keyFr);
+  }
+
+  /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */
+  public async blockNumber(): Promise<number> {
+    return await this.pxe.getBlockNumber();
+  }
+
+  /**
+   * Get the current timestamp
+   * @returns The current timestamp
+   */
+  public async timestamp(): Promise<number> {
+    const res = await this.pxe.getBlock(await this.blockNumber());
+    return res?.header.globalVariables.timestamp.toNumber() ?? 0;
+  }
+
+  /**
+   * Loads the value stored at the given slot in the public storage of the given contract.
+   * @param who - The address of the contract
+   * @param slot - The storage slot to lookup
+   * @returns The value stored at the given slot
+   */
+  public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
+    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
+    return storageValue;
+  }
+
+  /**
+   * Loads the value stored at the given slot in the private storage of the given contract.
+   * @param contract - The address of the contract
+   * @param owner - The owner for whom the notes are encrypted
+   * @param slot - The storage slot to lookup
+   * @returns The notes stored at the given slot
+   */
+  public async loadPrivate(owner: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<Note[]> {
+    const extendedNotes = await this.pxe.getNotes({
+      owner,
+      contractAddress: contract,
+      storageSlot: new Fr(slot),
+    });
+    return extendedNotes.map(extendedNote => extendedNote.note);
+  }
+}

package/src/utils/fee_juice.ts

@@ -0,0 +1,14 @@
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
+
+import type { PXE } from '../api/interfaces/pxe.js';
+
+/**
+ * Returns the owner's fee juice balance.
+ */
+export async function getFeeJuiceBalance(owner: AztecAddress, pxe: PXE): Promise<bigint> {
+  const slot = await deriveStorageSlotInMap(new Fr(1), owner);
+  return (await pxe.getPublicStorageAt(ProtocolContractAddress.FeeJuice, slot)).toBigInt();
+}

package/src/utils/field_compressed_string.ts

@@ -0,0 +1,27 @@
+import { Fr } from '@aztec/foundation/fields';
+
+/**
+ * The representation of a FieldCompressedString in aztec.nr
+ */
+interface NoirFieldCompressedString {
+  /**
+   * The field value of the string
+   */
+  value: bigint;
+}
+/**
+ * This turns
+ * @param field - The field that contains the string
+ * @returns - the string that is decoded from the field
+ */
+export const readFieldCompressedString = (field: NoirFieldCompressedString): string => {
+  const vals: number[] = Array.from(new Fr(field.value).toBuffer());
+
+  let str = '';
+  for (let i = 0; i < vals.length; i++) {
+    if (vals[i] != 0) {
+      str += String.fromCharCode(Number(vals[i]));
+    }
+  }
+  return str;
+};

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+export { generatePublicKey } from './pub_key.js';
+export {
+  type AztecAddressLike,
+  type EthAddressLike,
+  type EventSelectorLike,
+  type FieldLike,
+  type FunctionSelectorLike,
+  type U128Like,
+  type WrappedFieldLike,
+} from './abi_types.js';
+export {
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHash,
+  computeInnerAuthWitHashFromAction,
+  type IntentAction,
+  type IntentInnerHash,
+} from './authwit.js';
+export { waitForPXE } from './pxe.js';
+export { waitForNode, createAztecNodeClient, type AztecNode } from './node.js';
+export { getFeeJuiceBalance } from './fee_juice.js';
+export { readFieldCompressedString } from './field_compressed_string.js';

package/src/utils/node.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+export const waitForNode = async (node: AztecNode, logger?: Logger) => {
+  await retryUntil(async () => {
+    try {
+      logger?.verbose('Attempting to contact Aztec node...');
+      await node.getNodeInfo();
+      logger?.verbose('Contacted Aztec node');
+      return true;
+    } catch (error) {
+      logger?.verbose('Failed to contact Aztec Node');
+    }
+    return undefined;
+  }, 'RPC Get Node Info');
+};
+
+export { createAztecNodeClient, type AztecNode } from '@aztec/stdlib/interfaces/client';

package/src/utils/pub_key.ts

@@ -0,0 +1,13 @@
+import { Grumpkin } from '@aztec/foundation/crypto';
+import type { GrumpkinScalar } from '@aztec/foundation/fields';
+import type { PublicKey } from '@aztec/stdlib/keys';
+
+/**
+ * Method for generating a public grumpkin key from a private key.
+ * @param privateKey - The private key.
+ * @returns The generated public key.
+ */
+export function generatePublicKey(privateKey: GrumpkinScalar): Promise<PublicKey> {
+  const grumpkin = new Grumpkin();
+  return grumpkin.mul(grumpkin.generator(), privateKey);
+}

package/src/utils/pxe.ts

@@ -0,0 +1,17 @@
+import type { Logger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+export const waitForPXE = async (pxe: PXE, logger?: Logger) => {
+  await retryUntil(async () => {
+    try {
+      logger?.verbose('Attempting to contact PXE...');
+      await pxe.getNodeInfo();
+      logger?.verbose('Contacted PXE');
+      return true;
+    } catch (error) {
+      logger?.verbose('Failed to contact PXE');
+    }
+    return undefined;
+  }, 'RPC Get Node Info');
+};

package/src/wallet/account_wallet.ts

@@ -0,0 +1,242 @@
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { type ABIParameterVisibility, type FunctionAbi, FunctionType } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+
+import type { AccountInterface } from '../account/interface.js';
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
+import {
+  type IntentAction,
+  type IntentInnerHash,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHashFromAction,
+} from '../utils/authwit.js';
+import { BaseWallet } from './base_wallet.js';
+
+/**
+ * A wallet implementation that forwards authentication requests to a provided account.
+ */
+export class AccountWallet extends BaseWallet {
+  constructor(pxe: PXE, protected account: AccountInterface) {
+    super(pxe, [account.getAddress()]);
+  }
+
+  createTxExecutionRequest(exec: ExecutionRequestInit): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(exec);
+  }
+
+  getChainId(): Fr {
+    return this.account.getChainId();
+  }
+
+  getVersion(): Fr {
+    return this.account.getVersion();
+  }
+
+  override isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
+    return this.pxe.isL1ToL2MessageSynced(l1ToL2Message);
+  }
+
+  /**
+   * Computes an authentication witness from either a message hash or an intent.
+   *
+   * If a message hash is provided, it will create a witness for the hash directly.
+   * Otherwise, it will compute the message hash using the intent, along with the
+   * chain id and the version values provided by the wallet.
+   *
+   * @param messageHashOrIntent - The message hash of the intent to approve
+   * @returns The authentication witness
+   */
+  async createAuthWit(messageHashOrIntent: Fr | Buffer | IntentAction | IntentInnerHash): Promise<AuthWitness> {
+    let messageHash: Fr;
+    if (Buffer.isBuffer(messageHashOrIntent)) {
+      messageHash = Fr.fromBuffer(messageHashOrIntent);
+    } else if (messageHashOrIntent instanceof Fr) {
+      messageHash = messageHashOrIntent;
+    } else {
+      messageHash = await this.getMessageHash(messageHashOrIntent);
+    }
+
+    const witness = await this.account.createAuthWit(messageHash);
+    await this.pxe.addAuthWitness(witness);
+    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 hash or intent to authorize/revoke
+   * @param authorized - True to authorize, false to revoke authorization.
+   * @returns - A function interaction.
+   */
+  public async setPublicAuthWit(
+    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(this, 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() : 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> {
+    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 onBehalfOf - The address of the "approver"
+   * @param intent - The consumer and inner hash or the caller and action to lookup
+   *
+   * @returns - A struct containing the validity of the authwit in private and public contexts.
+   */
+  async lookupValidity(
+    onBehalfOf: AztecAddress,
+    intent: IntentInnerHash | IntentAction,
+  ): 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
+    const witness = await this.getAuthWitness(messageHash);
+    if (witness !== undefined) {
+      results.isValidInPrivate = (await new ContractFunctionInteraction(this, onBehalfOf, this.getLookupValidityAbi(), [
+        consumer,
+        innerHash,
+      ]).simulate()) as boolean;
+    }
+
+    // check public
+    results.isValidInPublic = (await new ContractFunctionInteraction(
+      this,
+      ProtocolContractAddress.AuthRegistry,
+      this.getIsConsumableAbi(),
+      [onBehalfOf, messageHash],
+    ).simulate()) as boolean;
+
+    return results;
+  }
+
+  /** Returns the complete address of the account that implements this wallet. */
+  public getCompleteAddress() {
+    return this.account.getCompleteAddress();
+  }
+
+  /** Returns the address of the account that implements this wallet. */
+  public override getAddress() {
+    return this.getCompleteAddress().address;
+  }
+
+  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.UNCONSTRAINED,
+      isInternal: false,
+      isStatic: false,
+      parameters: [{ name: 'message_hash', type: { kind: 'field' }, visibility: 'private' as ABIParameterVisibility }],
+      returnTypes: [{ kind: 'boolean' }],
+      errorTypes: {},
+    };
+  }
+
+  private getIsConsumableAbi(): FunctionAbi {
+    return {
+      name: 'unconstrained_is_consumable',
+      isInitializer: false,
+      functionType: FunctionType.UNCONSTRAINED,
+      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: {},
+    };
+  }
+}