@aztec/aztec.js 0.72.1 → 0.74.0

package/src/entrypoint/payload.ts

@@ -56,19 +56,22 @@ type EncodedFunctionCall = {
 
 /** Assembles an entrypoint payload */
 export abstract class EntrypointPayload {
-  #hashedArguments: HashedValues[] = [];
-  #functionCalls: EncodedFunctionCall[] = [];
-  #nonce: Fr;
-  #generatorIndex: number;
-
-  protected constructor(functionCalls: FunctionCall[], generatorIndex: number, nonce = Fr.random()) {
+  protected constructor(
+    private functionCalls: EncodedFunctionCall[],
+    private _hashedArguments: HashedValues[],
+    private generatorIndex: number,
+    private _nonce: Fr,
+  ) {}
+
+  protected static async create(functionCalls: FunctionCall[]) {
+    const hashedArguments: HashedValues[] = [];
     for (const call of functionCalls) {
-      this.#hashedArguments.push(HashedValues.fromValues(call.args));
+      hashedArguments.push(await HashedValues.fromValues(call.args));
     }
 
     /* eslint-disable camelcase */
-    this.#functionCalls = functionCalls.map((call, index) => ({
-      args_hash: this.#hashedArguments[index].hash,
+    const encodedFunctionCalls = functionCalls.map((call, index) => ({
+      args_hash: hashedArguments[index].hash,
       function_selector: call.selector.toField(),
       target_address: call.to.toField(),
       is_public: call.type == FunctionType.PUBLIC,
@@ -76,8 +79,10 @@ export abstract class EntrypointPayload {
     }));
     /* eslint-enable camelcase */
 
-    this.#generatorIndex = generatorIndex;
-    this.#nonce = nonce;
+    return {
+      encodedFunctionCalls,
+      hashedArguments,
+    };
   }
 
   /* eslint-disable camelcase */
@@ -86,7 +91,7 @@ export abstract class EntrypointPayload {
    * @internal
    */
   get function_calls() {
-    return this.#functionCalls;
+    return this.functionCalls;
   }
   /* eslint-enable camelcase */
 
@@ -95,14 +100,14 @@ export abstract class EntrypointPayload {
    * @internal
    */
   get nonce() {
-    return this.#nonce;
+    return this._nonce;
   }
 
   /**
    * The hashed arguments for the function calls
    */
   get hashedArguments() {
-    return this.#hashedArguments;
+    return this._hashedArguments;
   }
 
   /**
@@ -116,12 +121,12 @@ export abstract class EntrypointPayload {
    * @returns The hash of the payload
    */
   hash() {
-    return poseidon2HashWithSeparator(this.toFields(), this.#generatorIndex);
+    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
   }
 
   /** Serializes the function calls to an array of fields. */
   protected functionCallsToFields() {
-    return this.#functionCalls.flatMap(call => [
+    return this.functionCalls.flatMap(call => [
       call.args_hash,
       call.function_selector,
       call.target_address,
@@ -135,8 +140,9 @@ export abstract class EntrypointPayload {
    * @param functionCalls - The function calls to execute
    * @returns The execution payload
    */
-  static fromFunctionCalls(functionCalls: FunctionCall[]) {
-    return new AppEntrypointPayload(functionCalls, 0);
+  static async fromFunctionCalls(functionCalls: FunctionCall[]) {
+    const { encodedFunctionCalls, hashedArguments } = await this.create(functionCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, 0, Fr.random());
   }
 
   /**
@@ -145,12 +151,13 @@ export abstract class EntrypointPayload {
    * @param nonce - The nonce for the payload, used to emit a nullifier identifying the call
    * @returns The execution payload
    */
-  static fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
+  static async fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
     if (functionCalls.length > APP_MAX_CALLS) {
       throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
     }
     const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
-    return new AppEntrypointPayload(paddedCalls, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
   }
 
   /**
@@ -164,7 +171,14 @@ export abstract class EntrypointPayload {
     const feePayer = await feeOpts?.paymentMethod.getFeePayer(feeOpts?.gasSettings);
     const isFeePayer = !!feePayer && feePayer.equals(sender);
     const paddedCalls = padArrayEnd(calls, FunctionCall.empty(), FEE_MAX_CALLS);
-    return new FeeEntrypointPayload(paddedCalls, GeneratorIndex.FEE_PAYLOAD, isFeePayer);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new FeeEntrypointPayload(
+      encodedFunctionCalls,
+      hashedArguments,
+      GeneratorIndex.FEE_PAYLOAD,
+      Fr.random(),
+      isFeePayer,
+    );
   }
 }
 
@@ -179,8 +193,14 @@ class AppEntrypointPayload extends EntrypointPayload {
 class FeeEntrypointPayload extends EntrypointPayload {
   #isFeePayer: boolean;
 
-  constructor(functionCalls: FunctionCall[], generatorIndex: number, isFeePayer: boolean) {
-    super(functionCalls, generatorIndex);
+  constructor(
+    functionCalls: EncodedFunctionCall[],
+    hashedArguments: HashedValues[],
+    generatorIndex: number,
+    nonce: Fr,
+    isFeePayer: boolean,
+  ) {
+    super(functionCalls, hashedArguments, generatorIndex, nonce);
     this.#isFeePayer = isFeePayer;
   }
 
@@ -202,6 +222,12 @@ class FeeEntrypointPayload extends EntrypointPayload {
  * @param feePayload - A fee payload.
  * @returns A hash of a combined payload.
  */
-export function computeCombinedPayloadHash(appPayload: AppEntrypointPayload, feePayload: FeeEntrypointPayload): Fr {
-  return poseidon2HashWithSeparator([appPayload.hash(), feePayload.hash()], GeneratorIndex.COMBINED_PAYLOAD);
+export async function computeCombinedPayloadHash(
+  appPayload: AppEntrypointPayload,
+  feePayload: FeeEntrypointPayload,
+): Promise<Fr> {
+  return poseidon2HashWithSeparator(
+    [await appPayload.hash(), await feePayload.hash()],
+    GeneratorIndex.COMBINED_PAYLOAD,
+  );
 }

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -24,7 +24,7 @@ export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
    */
   override async getFunctionCalls(): Promise<FunctionCall[]> {
     const canonicalFeeJuice = await getCanonicalFeeJuice();
-    const selector = FunctionSelector.fromNameAndParameters(
+    const selector = await FunctionSelector.fromNameAndParameters(
       canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
     );
 

package/src/fee/private_fee_payment_method.ts

@@ -94,9 +94,9 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
     await this.wallet.createAuthWit({
       caller: this.paymentContract,
       action: {
-        name: 'setup_refund',
-        args: [this.wallet.getAddress().toField(), ...maxFee.toFields(), nonce],
-        selector: FunctionSelector.fromSignature('setup_refund((Field),(Field,Field),Field)'),
+        name: 'transfer_to_public',
+        args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), ...maxFee.toFields(), nonce],
+        selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),(Field,Field),Field)'),
         type: FunctionType.PRIVATE,
         isStatic: false,
         to: await this.getAsset(),
@@ -108,7 +108,7 @@ export class PrivateFeePaymentMethod implements FeePaymentMethod {
       {
         name: 'fee_entrypoint_private',
         to: this.paymentContract,
-        selector: FunctionSelector.fromSignature('fee_entrypoint_private((Field,Field),Field)'),
+        selector: await FunctionSelector.fromSignature('fee_entrypoint_private((Field,Field),Field)'),
         type: FunctionType.PRIVATE,
         isStatic: false,
         args: [...maxFee.toFields(), nonce],

package/src/fee/public_fee_payment_method.ts

@@ -82,33 +82,33 @@ export class PublicFeePaymentMethod implements FeePaymentMethod {
     const nonce = Fr.random();
     const maxFee = new U128(gasSettings.getFeeLimit().toBigInt());
 
-    return Promise.resolve([
-      this.wallet
-        .setPublicAuthWit(
-          {
-            caller: this.paymentContract,
-            action: {
-              name: 'transfer_in_public',
-              args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), ...maxFee.toFields(), nonce],
-              selector: FunctionSelector.fromSignature('transfer_in_public((Field),(Field),(Field,Field),Field)'),
-              type: FunctionType.PUBLIC,
-              isStatic: false,
-              to: await this.getAsset(),
-              returnTypes: [],
-            },
-          },
-          true,
-        )
-        .request(),
+    const setPublicAuthWitInteraction = await this.wallet.setPublicAuthWit(
+      {
+        caller: this.paymentContract,
+        action: {
+          name: 'transfer_in_public',
+          args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), ...maxFee.toFields(), nonce],
+          selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),(Field,Field),Field)'),
+          type: FunctionType.PUBLIC,
+          isStatic: false,
+          to: await this.getAsset(),
+          returnTypes: [],
+        },
+      },
+      true,
+    );
+
+    return [
+      await setPublicAuthWitInteraction.request(),
       {
         name: 'fee_entrypoint_public',
         to: this.paymentContract,
-        selector: FunctionSelector.fromSignature('fee_entrypoint_public((Field,Field),Field)'),
+        selector: await FunctionSelector.fromSignature('fee_entrypoint_public((Field,Field),Field)'),
         type: FunctionType.PRIVATE,
         isStatic: false,
         args: [...maxFee.toFields(), nonce],
         returnTypes: [],
       },
-    ]);
+    ];
   }
 }

package/src/index.ts

@@ -147,14 +147,12 @@ export { elapsed } from '@aztec/foundation/timer';
 export { type FieldsOf } from '@aztec/foundation/types';
 export { fileURLToPath } from '@aztec/foundation/url';
 
-export { EthCheatCodes, deployL1Contract, deployL1Contracts, type DeployL1Contracts } from '@aztec/ethereum';
-
 // Start of section that exports public api via granular api.
 // Here you *can* do `export *` as the granular api defacto exports things explicitly.
 // This entire index file will be deprecated at some point after we're satisfied.
 export * from './api/abi.js';
 export * from './api/fee.js';
-export * from './api/init.js';
+export * from './api/addresses.js';
+export * from './api/ethereum.js';
 // Granular export, even if not in the api folder
 export * from './contract/index.js';
-export * from './api/addresses.js';

package/src/utils/anvil_test_watcher.ts

@@ -15,9 +15,12 @@ import type * as chains from 'viem/chains';
  * block within the slot. And if so, it will time travel into the next slot.
  */
 export class AnvilTestWatcher {
+  private isSandbox: boolean = false;
+
   private rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, chains.Chain>>;
 
   private filledRunningPromise?: RunningPromise;
+  private mineIfOutdatedPromise?: RunningPromise;
 
   private logger: Logger = createLogger(`aztecjs:utils:watcher`);
 
@@ -36,6 +39,10 @@ export class AnvilTestWatcher {
     this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
   }
 
+  setIsSandbox(isSandbox: boolean) {
+    this.isSandbox = isSandbox;
+  }
+
   async start() {
     if (this.filledRunningPromise) {
       throw new Error('Watcher already watching for filled slot');
@@ -48,8 +55,10 @@ export class AnvilTestWatcher {
     const isAutoMining = await this.cheatcodes.isAutoMining();
 
     if (isAutoMining) {
-      this.filledRunningPromise = new RunningPromise(() => this.mineIfSlotFilled(), this.logger, 1000);
+      this.filledRunningPromise = new RunningPromise(() => this.warpTimeIfNeeded(), this.logger, 1000);
       this.filledRunningPromise.start();
+      this.mineIfOutdatedPromise = new RunningPromise(() => this.mineIfOutdated(), this.logger, 1000);
+      this.mineIfOutdatedPromise.start();
       this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
     } else {
       this.logger.info(`Watcher not started because not auto mining`);
@@ -58,25 +67,64 @@ export class AnvilTestWatcher {
 
   async stop() {
     await this.filledRunningPromise?.stop();
+    await this.mineIfOutdatedPromise?.stop();
+  }
+
+  async mineIfOutdated() {
+    // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
+    if (!this.dateProvider) {
+      return;
+    }
+
+    const l1Time = (await this.cheatcodes.timestamp()) * 1000;
+    const wallTime = this.dateProvider.now();
+
+    // If the wall time is more than 24 seconds away from L1 time,
+    // mine a block and sync the clocks
+    if (Math.abs(wallTime - l1Time) > 24 * 1000) {
+      this.logger.warn(`Wall time is more than 24 seconds away from L1 time, mining a block and syncing clocks`);
+      await this.cheatcodes.evmMine();
+      const newL1Time = await this.cheatcodes.timestamp();
+      this.logger.info(`New L1 time: ${newL1Time}`);
+      this.dateProvider.setTime(newL1Time * 1000);
+    }
   }
 
-  async mineIfSlotFilled() {
+  async warpTimeIfNeeded() {
     try {
       const currentSlot = await this.rollup.read.getCurrentSlot();
       const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
       const blockLog = await this.rollup.read.getBlock([pendingBlockNumber]);
+      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([currentSlot + 1n]));
 
       if (currentSlot === blockLog.slotNumber) {
         // We should jump to the next slot
-        const timestamp = await this.rollup.read.getTimestampForSlot([currentSlot + 1n]);
         try {
-          await this.cheatcodes.warp(Number(timestamp));
-          this.dateProvider?.setTime(Number(timestamp) * 1000);
+          await this.cheatcodes.warp(nextSlotTimestamp);
+          this.dateProvider?.setTime(nextSlotTimestamp * 1000);
         } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${timestamp}: ${e}`);
+          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
         }
 
         this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
+        return;
+      }
+
+      // If we are not in sandbox, we don't need to warp time
+      if (!this.isSandbox) {
+        return;
+      }
+
+      const currentTimestamp = this.dateProvider?.now() ?? Date.now();
+      if (currentTimestamp > nextSlotTimestamp * 1000) {
+        try {
+          await this.cheatcodes.warp(nextSlotTimestamp);
+          this.dateProvider?.setTime(nextSlotTimestamp * 1000);
+        } catch (e) {
+          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
+        }
+
+        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
       }
     } catch (err) {
       this.logger.error('mineIfSlotFilled failed');

package/src/utils/authwit.ts

@@ -50,17 +50,17 @@ export type IntentAction = {
  * @param metadata - The metadata for the intent (chainId, version)
  * @returns The message hash for the action
  */
-export const computeAuthWitMessageHash = (intent: IntentInnerHash | IntentAction, metadata: IntentMetadata) => {
+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 ? intent.action.request() : intent.action;
+    const action = intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
     return computeOuterAuthWitHash(
       action.to,
       chainId,
       version,
-      computeInnerAuthWitHashFromAction(intent.caller, action),
+      await computeInnerAuthWitHashFromAction(intent.caller, action),
     );
   } else {
     const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
@@ -69,8 +69,12 @@ export const computeAuthWitMessageHash = (intent: IntentInnerHash | IntentAction
 };
 // docs:end:authwit_computeAuthWitMessageHash
 
-export const computeInnerAuthWitHashFromAction = (caller: AztecAddress, action: FunctionCall) =>
-  computeInnerAuthWitHash([caller.toField(), action.selector.toField(), HashedValues.fromValues(action.args).hash]);
+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.

package/src/utils/chain_monitor.ts

@@ -1,4 +1,4 @@
-import { type RollupContract } from '@aztec/ethereum';
+import { type RollupContract } from '@aztec/ethereum/contracts';
 import { createLogger } from '@aztec/foundation/log';
 
 import { type PublicClient } from 'viem';
@@ -27,7 +27,7 @@ export class ChainMonitor {
     if (this.handle) {
       throw new Error('Chain monitor already started');
     }
-    this.handle = setInterval(() => this.run(), this.intervalMs);
+    this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
   }
 
   stop() {
@@ -37,6 +37,12 @@ export class ChainMonitor {
     }
   }
 
+  private safeRun() {
+    void this.run().catch(error => {
+      this.logger.error('Error in chain monitor loop', error);
+    });
+  }
+
   async run() {
     const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({ cacheTime: 0 }));
     if (this.l1BlockNumber === newL1BlockNumber) {

package/src/utils/cheat_codes.ts

@@ -1,7 +1,8 @@
 import { type EpochProofClaim, type Note, type PXE } from '@aztec/circuit-types';
 import { type AztecAddress, EthAddress, Fr } from '@aztec/circuits.js';
 import { deriveStorageSlotInMap } from '@aztec/circuits.js/hash';
-import { EthCheatCodes, type L1ContractAddresses } from '@aztec/ethereum';
+import { EthCheatCodes } from '@aztec/ethereum/eth-cheatcodes';
+import { type L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
 
@@ -95,8 +96,8 @@ export class RollupCheatCodes {
     /** Slot duration */ slotDuration: bigint;
   }> {
     const [epochDuration, slotDuration] = await Promise.all([
-      this.rollup.read.EPOCH_DURATION(),
-      this.rollup.read.SLOT_DURATION(),
+      this.rollup.read.getEpochDuration(),
+      this.rollup.read.getSlotDuration(),
     ]);
     return { epochDuration, slotDuration };
   }
@@ -127,7 +128,7 @@ export class RollupCheatCodes {
    */
   public async advanceSlots(howMany: number) {
     const l1Timestamp = (await this.client.getBlock()).timestamp;
-    const slotDuration = await this.rollup.read.SLOT_DURATION();
+    const slotDuration = await this.rollup.read.getSlotDuration();
     const timeToWarp = BigInt(howMany) * slotDuration;
     await this.ethCheatCodes.warp(l1Timestamp + timeToWarp, true);
     const [slot, epoch] = await Promise.all([this.getSlot(), this.getEpoch()]);
@@ -223,7 +224,7 @@ export class AztecCheatCodes {
    * @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): Fr {
+  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);
   }

package/src/utils/l1_contracts.ts

@@ -1,4 +1,4 @@
-import { type L1ContractAddresses } from '@aztec/ethereum';
+import { type L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { retryUntil } from '@aztec/foundation/retry';
 
 import { createPXEClient } from '../rpc_clients/index.js';

package/src/utils/portal_manager.ts

@@ -7,7 +7,7 @@ import {
   type SiblingPath,
   computeSecretHash,
 } from '@aztec/aztec.js';
-import { extractEvent } from '@aztec/ethereum';
+import { extractEvent } from '@aztec/ethereum/utils';
 import { sha256ToField } from '@aztec/foundation/crypto';
 import { FeeJuicePortalAbi, OutboxAbi, TestERC20Abi, TokenPortalAbi } from '@aztec/l1-artifacts';
 
@@ -49,9 +49,9 @@ function stringifyEthAddress(address: EthAddress | Hex, name?: string) {
 }
 
 /** Generates a pair secret and secret hash */
-export function generateClaimSecret(logger?: Logger): [Fr, Fr] {
+export async function generateClaimSecret(logger?: Logger): Promise<[Fr, Fr]> {
   const secret = Fr.random();
-  const secretHash = computeSecretHash(secret);
+  const secretHash = await computeSecretHash(secret);
   logger?.verbose(`Generated claim secret=${secret.toString()} hash=${secretHash.toString()}`);
   return [secret, secretHash];
 }
@@ -144,7 +144,7 @@ export class L1FeeJuicePortalManager {
    * @param mint - Whether to mint the tokens before sending (only during testing).
    */
   public async bridgeTokensPublic(to: AztecAddress, amount: bigint, mint = false): Promise<L2AmountClaim> {
-    const [claimSecret, claimSecretHash] = generateClaimSecret();
+    const [claimSecret, claimSecretHash] = await generateClaimSecret();
     if (mint) {
       await this.tokenManager.mint(amount, this.walletClient.account.address);
     }

package/src/wallet/account_wallet.ts

@@ -55,7 +55,7 @@ export class AccountWallet extends BaseWallet {
     } else if (messageHashOrIntent instanceof Fr) {
       messageHash = messageHashOrIntent;
     } else {
-      messageHash = this.getMessageHash(messageHashOrIntent);
+      messageHash = await this.getMessageHash(messageHashOrIntent);
     }
 
     const witness = await this.account.createAuthWit(messageHash);
@@ -72,17 +72,17 @@ export class AccountWallet extends BaseWallet {
    * @param authorized - True to authorize, false to revoke authorization.
    * @returns - A function interaction.
    */
-  public setPublicAuthWit(
+  public async setPublicAuthWit(
     messageHashOrIntent: Fr | Buffer | IntentInnerHash | IntentAction,
     authorized: boolean,
-  ): ContractFunctionInteraction {
+  ): Promise<ContractFunctionInteraction> {
     let messageHash: Fr;
     if (Buffer.isBuffer(messageHashOrIntent)) {
       messageHash = Fr.fromBuffer(messageHashOrIntent);
     } else if (messageHashOrIntent instanceof Fr) {
       messageHash = messageHashOrIntent;
     } else {
-      messageHash = this.getMessageHash(messageHashOrIntent);
+      messageHash = await this.getMessageHash(messageHashOrIntent);
     }
 
     return new ContractFunctionInteraction(this, ProtocolContractAddress.AuthRegistry, this.getSetAuthorizedAbi(), [
@@ -91,16 +91,17 @@ export class AccountWallet extends BaseWallet {
     ]);
   }
 
-  private getInnerHashAndConsumer(intent: IntentInnerHash | IntentAction): {
+  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 ? intent.action.request() : intent.action;
+      const action =
+        intent.action instanceof ContractFunctionInteraction ? await intent.action.request() : intent.action;
       return {
-        innerHash: computeInnerAuthWitHashFromAction(intent.caller, action),
+        innerHash: await computeInnerAuthWitHashFromAction(intent.caller, action),
         consumer: action.to,
       };
     } else if (Buffer.isBuffer(intent.innerHash)) {
@@ -115,7 +116,7 @@ export class AccountWallet extends BaseWallet {
    * @param intent - A tuple of (consumer and inner hash) or (caller and action)
    * @returns The message hash
    */
-  private getMessageHash(intent: IntentInnerHash | IntentAction): Fr {
+  private getMessageHash(intent: IntentInnerHash | IntentAction): Promise<Fr> {
     const chainId = this.getChainId();
     const version = this.getVersion();
     return computeAuthWitMessageHash(intent, { chainId, version });
@@ -140,9 +141,9 @@ export class AccountWallet extends BaseWallet {
     /** boolean flag indicating if the authwit is valid in public context */
     isValidInPublic: boolean;
   }> {
-    const { innerHash, consumer } = this.getInnerHashAndConsumer(intent);
+    const { innerHash, consumer } = await this.getInnerHashAndConsumer(intent);
 
-    const messageHash = this.getMessageHash(intent);
+    const messageHash = await this.getMessageHash(intent);
     const results = { isValidInPrivate: false, isValidInPublic: false };
 
     // Check private

package/src/wallet/account_wallet_with_private_key.ts

@@ -30,9 +30,9 @@ export class AccountWalletWithSecretKey extends AccountWallet {
    * note - this ensures that the address secret always corresponds to an address point with y being positive
    * dev - this is also referred to as the address secret, which decrypts payloads encrypted to an address point
    */
-  public getEncryptionSecret() {
+  public async getEncryptionSecret() {
     return computeAddressSecret(
-      this.getCompleteAddress().getPreaddress(),
+      await this.getCompleteAddress().getPreaddress(),
       deriveMasterIncomingViewingSecretKey(this.getSecretKey()),
     );
   }

package/src/wallet/base_wallet.ts

@@ -1,5 +1,7 @@
 import {
   type AuthWitness,
+  type ContractClassMetadata,
+  type ContractMetadata,
   type EventMetadataDefinition,
   type ExtendedNote,
   type GetContractClassLogsResponse,
@@ -22,7 +24,6 @@ import {
 import {
   type AztecAddress,
   type CompleteAddress,
-  type ContractClassWithId,
   type ContractInstanceWithAddress,
   type Fr,
   type GasFees,
@@ -66,15 +67,6 @@ export abstract class BaseWallet implements Wallet {
   getAddress() {
     return this.getCompleteAddress().address;
   }
-  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.pxe.getContractInstance(address);
-  }
-  getContractClass(id: Fr): Promise<ContractClassWithId | undefined> {
-    return this.pxe.getContractClass(id);
-  }
-  getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
-    return this.pxe.getContractArtifact(id);
-  }
   addCapsule(capsule: Fr[]): Promise<void> {
     return this.pxe.addCapsule(capsule);
   }
@@ -182,18 +174,15 @@ export abstract class BaseWallet implements Wallet {
   getAuthWitness(messageHash: Fr) {
     return this.pxe.getAuthWitness(messageHash);
   }
-  isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
-    return this.pxe.isContractClassPubliclyRegistered(id);
-  }
-  isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
-    return this.pxe.isContractPubliclyDeployed(address);
-  }
-  isContractInitialized(address: AztecAddress): Promise<boolean> {
-    return this.pxe.isContractInitialized(address);
-  }
   getPXEInfo(): Promise<PXEInfo> {
     return this.pxe.getPXEInfo();
   }
+  getContractClassMetadata(id: Fr, includeArtifact: boolean = false): Promise<ContractClassMetadata> {
+    return this.pxe.getContractClassMetadata(id, includeArtifact);
+  }
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata> {
+    return this.pxe.getContractMetadata(address);
+  }
   getPrivateEvents<T>(
     event: EventMetadataDefinition,
     from: number,

package/dest/api/init.d.ts

@@ -1,7 +0,0 @@
-/**
- * This should only be needed to be called in CJS environments that don't have top level await.
- * Initializes any asynchronous subsystems required to use the library.
- * At time of writing, this is just our foundation crypto lib.
- */
-export declare function initAztecJs(): Promise<void>;
-//# sourceMappingURL=init.d.ts.map

package/dest/api/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/api/init.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,WAAW,kBAEhC"}