@aztec/aztec.js 3.0.0-canary.a9708bd → 3.0.0-devnet.2

package/src/api/events.ts

@@ -0,0 +1,44 @@
+import { type EventMetadataDefinition, EventSelector, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+
+/**
+ * Returns decoded public events given search parameters.
+ * @param node - The node to request events from
+ * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
+ * @param from - The block number to search from.
+ * @param limit - The amount of blocks to search.
+ * @returns - The deserialized events.
+ */
+export async function getDecodedPublicEvents<T>(
+  node: AztecNode,
+  eventMetadataDef: EventMetadataDefinition,
+  from: number,
+  limit: number,
+): Promise<T[]> {
+  const { logs } = await node.getPublicLogs({
+    fromBlock: from,
+    toBlock: from + limit,
+  });
+
+  const decodedEvents = logs
+    .map(log => {
+      // +1 for the event selector
+      const expectedLength = eventMetadataDef.fieldNames.length + 1;
+      if (log.log.fields.length !== expectedLength) {
+        throw new Error(
+          `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.fields.length}.`,
+        );
+      }
+
+      const logFields = log.log.getEmittedFields();
+      // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
+      if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
+        return undefined;
+      }
+
+      return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
+    })
+    .filter(log => log !== undefined) as T[];
+
+  return decodedEvents;
+}

package/src/api/fee.ts

@@ -1,5 +1,4 @@
-export type { FeePaymentMethod } from '@aztec/entrypoints/interfaces';
-export { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
+export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
 export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
 export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';
 export { FeeJuicePaymentMethodWithClaim } from '../fee/fee_juice_payment_method_with_claim.js';

package/src/api/keys.ts

@@ -0,0 +1,8 @@
+export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
+export {
+  computeAppNullifierSecretKey,
+  deriveKeys,
+  deriveMasterIncomingViewingSecretKey,
+  deriveMasterNullifierSecretKey,
+} from '@aztec/stdlib/keys';
+export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/log.ts

@@ -1 +1,2 @@
 export { createLogger, type Logger } from '@aztec/foundation/log';
+export { LogId, type LogFilter } from '@aztec/stdlib/logs';

package/src/api/messaging.ts

@@ -0,0 +1,2 @@
+export { L1ToL2Message, L2Actor, L1Actor } from '@aztec/stdlib/messaging';
+export { isL1ToL2MessageReady, waitForL1ToL2MessageReady } from '../utils/cross_chain.js';

package/src/api/node.ts

@@ -0,0 +1,20 @@
+/**
+ * The `node` module provides utilities for connecting to and interacting with an Aztec node.
+ *
+ * The primary function is {@link createAztecNodeClient}, which creates a JSON-RPC client
+ * that connects to a running Aztec node instance. Use {@link waitForNode} to wait for
+ * the node to be ready before proceeding.
+ *
+ * @example
+ * ```ts
+ * import { createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+ *
+ * const node = createAztecNodeClient('http://localhost:8080');
+ * await waitForNode(node);
+ * const blockNumber = await node.getBlockNumber();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createAztecNodeClient, waitForNode, type AztecNode } from '../utils/node.js';
+export { type NodeInfo } from '@aztec/stdlib/contract';

package/src/api/note.ts

@@ -0,0 +1 @@
+export { UniqueNote, Comparator, Note } from '@aztec/stdlib/note';

package/src/api/protocol.ts

@@ -0,0 +1,2 @@
+export { ProtocolContractAddress } from '@aztec/protocol-contracts';
+export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';

package/src/api/trees.ts

@@ -0,0 +1,2 @@
+export { SiblingPath } from '@aztec/foundation/trees';
+export { MerkleTreeId, merkleTreeIds } from '@aztec/stdlib/trees';

package/src/api/tx.ts

@@ -0,0 +1,11 @@
+export {
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  Capsule,
+  HashedValues,
+  GlobalVariables,
+  TxProfileResult,
+} from '@aztec/stdlib/tx';

package/src/api/utils.ts

@@ -1,21 +1,14 @@
-export { generatePublicKey } from '../utils/pub_key.js';
-export {
-  type AztecAddressLike,
-  type EthAddressLike,
-  type EventSelectorLike,
-  type FieldLike,
-  type FunctionSelectorLike,
-  type U128Like,
-  type WrappedFieldLike,
-} from '../utils/abi_types.js';
-export {
-  computeAuthWitMessageHash,
-  computeInnerAuthWitHashFromAction,
-  type IntentAction,
-  type IntentInnerHash,
-} from '../utils/authwit.js';
-export { computeInnerAuthWitHash } from '@aztec/stdlib/auth-witness';
-export { waitForPXE } from '../utils/pxe.js';
-export { waitForNode, createAztecNodeClient, type AztecNode } from '../utils/node.js';
+/**
+ * Utility functions for aztec.js.
+ *
+ * NOTE: This module contains low-usage utilities and may be deprecated in the future.
+ * Prefer using more specific modules:
+ * - Node connection utilities → `@aztec/aztec.js/node`
+ * - Type converters → `@aztec/aztec.js/abi`
+ * - Key generation → `@aztec/aztec.js/keys`
+ * - Messaging utilities → `@aztec/aztec.js/messaging`
+ */
+
+// Low-usage utilities - consider these internal/experimental
 export { getFeeJuiceBalance } from '../utils/fee_juice.js';
 export { readFieldCompressedString } from '../utils/field_compressed_string.js';

package/src/api/wallet.ts

@@ -1,7 +1,35 @@
 export {
-  AccountWallet,
-  AccountWalletWithSecretKey,
-  SignerlessWallet,
-  getWallet,
+  type Aliased,
+  type ContractInstanceAndArtifact,
+  type UserFeeOptions,
+  type SimulateOptions,
+  type ProfileOptions,
+  type SendOptions,
+  type BatchableMethods,
+  type BatchedMethod,
+  type BatchedMethodResult,
+  type BatchedMethodResultWrapper,
+  type BatchResults,
   type Wallet,
-} from '../wallet/index.js';
+  ContractInstantiationDataSchema,
+  FunctionCallSchema,
+  ExecutionPayloadSchema,
+  UserFeeOptionsSchema,
+  WalletSimulationFeeOptionSchema,
+  SendOptionsSchema,
+  SimulateOptionsSchema,
+  ProfileOptionsSchema,
+  InstanceDataSchema,
+  MessageHashOrIntentSchema,
+  BatchedMethodSchema,
+  ContractMetadataSchema,
+  ContractClassMetadataSchema,
+  EventMetadataDefinitionSchema,
+  WalletSchema,
+} from '../wallet/wallet.js';
+
+export { type FeeOptions, BaseWallet } from '../wallet/base_wallet.js';
+
+export { AccountManager } from '../wallet/account_manager.js';
+
+export { type DeployAccountOptions, DeployAccountMethod } from '../wallet/deploy_account_method.js';

package/src/contract/base_contract_interaction.ts

@@ -1,22 +1,10 @@
-import {
-  GAS_ESTIMATION_DA_GAS_LIMIT,
-  GAS_ESTIMATION_L2_GAS_LIMIT,
-  GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT,
-  GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT,
-} from '@aztec/constants';
-import type { FeeOptions, TxExecutionOptions, UserFeeOptions } from '@aztec/entrypoints/interfaces';
 import type { ExecutionPayload } from '@aztec/entrypoints/payload';
 import { createLogger } from '@aztec/foundation/log';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import type { Capsule, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
+import type { Capsule } from '@aztec/stdlib/tx';
 
-import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
 import type { Wallet } from '../wallet/wallet.js';
-import { getGasLimits } from './get_gas_limits.js';
-import type { RequestMethodOptions, SendMethodOptions } from './interaction_options.js';
-import { ProvenTx } from './proven_tx.js';
+import { type RequestInteractionOptions, type SendInteractionOptions, toSendOptions } from './interaction_options.js';
 import { SentTx } from './sent_tx.js';
 
 /**
@@ -32,54 +20,13 @@ export abstract class BaseContractInteraction {
     protected capsules: Capsule[] = [],
   ) {}
 
-  /**
-   * Create a transaction execution request ready to be simulated.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns A transaction execution request.
-   */
-  public abstract create(options?: SendMethodOptions): Promise<TxExecutionRequest>;
-
   /**
    * Returns an execution request that represents this operation.
    * Can be used as a building block for constructing batch requests.
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns An execution request wrapped in promise.
    */
-  public abstract request(options?: RequestMethodOptions): Promise<ExecutionPayload>;
-
-  /**
-   * Creates a transaction execution request, simulates and proves it. Differs from .prove in
-   * that its result does not include the wallet nor the composed tx object, but only the proving result.
-   * This object can then be used to either create a ProvenTx ready to be sent, or directly send the transaction.
-   * @param options - optional arguments to be used in the creation of the transaction
-   * @returns The proving result.
-   */
-  protected async proveInternal(options: SendMethodOptions): Promise<TxProvingResult> {
-    if (options.from !== AztecAddress.ZERO && !options.from.equals(this.wallet.getAddress())) {
-      throw new Error(
-        `The address provided as from does not match the wallet address. Expected ${this.wallet.getAddress().toString()}, got ${options.from.toString()}.`,
-      );
-    }
-    const txRequest = await this.create(options);
-    return await this.wallet.proveTx(txRequest);
-  }
-
-  // docs:start:prove
-  /**
-   * Proves a transaction execution request and returns a tx object ready to be sent.
-   * @param options - optional arguments to be used in the creation of the transaction
-   * @returns The resulting transaction
-   */
-  public async prove(options: SendMethodOptions): Promise<ProvenTx> {
-    // docs:end:prove
-    const txProvingResult = await this.proveInternal(options);
-    return new ProvenTx(
-      this.wallet,
-      await txProvingResult.toTx(),
-      txProvingResult.getOffchainEffects(),
-      txProvingResult.stats,
-    );
-  }
+  public abstract request(options?: RequestInteractionOptions): Promise<ExecutionPayload>;
 
   // docs:start:send
   /**
@@ -87,93 +34,17 @@ export abstract class BaseContractInteraction {
    * This function throws an error if called on a utility function.
    * It creates and signs the transaction if necessary, and returns a SentTx instance,
    * which can be used to track the transaction status, receipt, and events.
-   * @param options - An optional object containing 'from' property representing
-   * the AztecAddress of the sender. If not provided, the default address is used.
+   * @param options - An object containing 'from' property representing
+   * the AztecAddress of the sender and optional fee configuration
    * @returns A SentTx instance for tracking the transaction status and information.
    */
-  public send(options: SendMethodOptions): SentTx {
+  public send(options: SendInteractionOptions): SentTx {
     // docs:end:send
     const sendTx = async () => {
-      const txProvingResult = await this.proveInternal(options);
-      return this.wallet.sendTx(await txProvingResult.toTx());
+      const executionPayload = await this.request(options);
+      const sendOptions = await toSendOptions(options);
+      return this.wallet.sendTx(executionPayload, sendOptions);
     };
     return new SentTx(this.wallet, sendTx);
   }
-
-  // docs:start:estimateGas
-  /**
-   * Estimates gas for a given tx request and returns gas limits for it.
-   * @param options - Options.
-   * @returns Gas limits.
-   */
-  public async estimateGas(
-    options: Omit<SendMethodOptions, 'estimateGas'>,
-  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
-    // docs:end:estimateGas
-    const txRequest = await this.create({ ...options, fee: { ...options?.fee, estimateGas: true } });
-    return {
-      gasLimits: txRequest.txContext.gasSettings.gasLimits,
-      teardownGasLimits: txRequest.txContext.gasSettings.teardownGasLimits,
-    };
-  }
-
-  /**
-   * Returns default fee options based on the user opts without running a simulation for gas estimation.
-   * @param fee - User-provided fee options.
-   */
-  protected async getDefaultFeeOptions(fee: UserFeeOptions | undefined): Promise<FeeOptions> {
-    const maxFeesPerGas =
-      fee?.gasSettings?.maxFeesPerGas ?? (await this.wallet.getCurrentBaseFees()).mul(1 + (fee?.baseFeePadding ?? 0.5));
-    const paymentMethod = fee?.paymentMethod ?? new FeeJuicePaymentMethod(this.wallet.getAddress());
-    const gasSettings: GasSettings = GasSettings.default({ ...fee?.gasSettings, maxFeesPerGas });
-    this.log.debug(`Using L2 gas settings`, gasSettings);
-    return { gasSettings, paymentMethod };
-  }
-
-  // docs:start:getFeeOptions
-  /**
-   * Return fee options based on the user opts, estimating tx gas if needed.
-   * @param executionPayload - Execution payload to get the fee for
-   * @param fee - User-provided fee options.
-   * @param options - Additional options for the transaction. They must faithfully represent the tx to get accurate fee estimates
-   * @returns Fee options for the actual transaction.
-   */
-  protected async getFeeOptions(
-    executionPayload: ExecutionPayload,
-    fee: UserFeeOptions = {},
-    options: TxExecutionOptions,
-  ): Promise<FeeOptions> {
-    // docs:end:getFeeOptions
-    const defaultFeeOptions = await this.getDefaultFeeOptions(fee);
-    const paymentMethod = defaultFeeOptions.paymentMethod;
-    const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
-    const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
-
-    let gasSettings = defaultFeeOptions.gasSettings;
-    if (fee?.estimateGas) {
-      // Use unrealistically high gas limits for estimation to avoid running out of gas.
-      // They will be tuned down after the simulation.
-      const gasSettingsForEstimation = new GasSettings(
-        new Gas(GAS_ESTIMATION_DA_GAS_LIMIT, GAS_ESTIMATION_L2_GAS_LIMIT),
-        new Gas(GAS_ESTIMATION_TEARDOWN_DA_GAS_LIMIT, GAS_ESTIMATION_TEARDOWN_L2_GAS_LIMIT),
-        maxFeesPerGas,
-        maxPriorityFeesPerGas,
-      );
-      const feeForEstimation: FeeOptions = { paymentMethod, gasSettings: gasSettingsForEstimation };
-      const txRequest = await this.wallet.createTxExecutionRequest(executionPayload, feeForEstimation, options);
-      const simulationResult = await this.wallet.simulateTx(
-        txRequest,
-        true /*simulatePublic*/,
-        undefined /* skipTxValidation */,
-        true /* skipFeeEnforcement */,
-      );
-      const { gasLimits, teardownGasLimits } = getGasLimits(simulationResult, fee?.estimatedGasPadding);
-      gasSettings = GasSettings.from({ maxFeesPerGas, maxPriorityFeesPerGas, gasLimits, teardownGasLimits });
-      this.log.verbose(
-        `Estimated gas limits for tx: DA=${gasLimits.daGas} L2=${gasLimits.l2Gas} teardownDA=${teardownGasLimits.daGas} teardownL2=${teardownGasLimits.l2Gas}`,
-      );
-    }
-
-    return { gasSettings, paymentMethod };
-  }
 }

package/src/contract/batch_call.ts

@@ -1,49 +1,37 @@
 import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import type { Wallet } from '../wallet/wallet.js';
 import { BaseContractInteraction } from './base_contract_interaction.js';
-import type { RequestMethodOptions, SendMethodOptions, SimulateMethodOptions } from './interaction_options.js';
+import {
+  type RequestInteractionOptions,
+  type SimulateInteractionOptions,
+  toSimulateOptions,
+} from './interaction_options.js';
 
 /** A batch of function calls to be sent as a single transaction through a wallet. */
 export class BatchCall extends BaseContractInteraction {
   constructor(
     wallet: Wallet,
-    protected calls: BaseContractInteraction[],
+    protected interactions: (BaseContractInteraction | ExecutionPayload)[],
   ) {
     super(wallet);
   }
 
-  /**
-   * Create a transaction execution request that represents this batch, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns A Promise that resolves to a transaction instance.
-   */
-  public async create(options: SendMethodOptions = { from: this.wallet.getAddress() }): Promise<TxExecutionRequest> {
-    const requestWithoutFee = await this.request(options);
-
-    const { fee: userFee, txNonce, cancellable } = options;
-    const fee = await this.getFeeOptions(requestWithoutFee, userFee, { txNonce, cancellable });
-
-    return await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, { txNonce, cancellable });
-  }
-
   /**
    * Returns an execution request that represents this operation.
    * @param options - An optional object containing additional configuration for the request generation.
    * @returns An execution payload wrapped in promise.
    */
-  public async request(options: RequestMethodOptions = {}): Promise<ExecutionPayload> {
-    const requests = await this.getRequests();
-    const combinedPayload = mergeExecutionPayloads(requests);
-    return new ExecutionPayload(
-      combinedPayload.calls,
-      combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
-      combinedPayload.capsules.concat(options.capsules ?? []),
-      combinedPayload.extraHashedArgs,
-    );
+  public async request(options: RequestInteractionOptions = {}): Promise<ExecutionPayload> {
+    const requests = await this.getExecutionPayloads();
+    const feeExecutionPayload = options.fee?.paymentMethod
+      ? await options.fee.paymentMethod.getExecutionPayload()
+      : undefined;
+    const finalExecutionPayload = feeExecutionPayload
+      ? mergeExecutionPayloads([feeExecutionPayload, ...requests])
+      : mergeExecutionPayloads([...requests]);
+    return finalExecutionPayload;
   }
 
   /**
@@ -55,8 +43,8 @@ export class BatchCall extends BaseContractInteraction {
    * @param options - An optional object containing additional configuration for the transaction.
    * @returns The result of the transaction as returned by the contract function.
    */
-  public async simulate(options: SimulateMethodOptions): Promise<any> {
-    const { indexedExecutionPayloads, utility } = (await this.getRequests()).reduce<{
+  public async simulate(options: SimulateInteractionOptions): Promise<any> {
+    const { indexedExecutionPayloads, utility } = (await this.getExecutionPayloads()).reduce<{
       /** Keep track of the number of private calls to retrieve the return values */
       privateIndex: 0;
       /** Keep track of the number of public calls to retrieve the return values */
@@ -84,53 +72,56 @@ export class BatchCall extends BaseContractInteraction {
 
     const payloads = indexedExecutionPayloads.map(([request]) => request);
     const combinedPayload = mergeExecutionPayloads(payloads);
-    const requestWithoutFee = new ExecutionPayload(
+    const executionPayload = new ExecutionPayload(
       combinedPayload.calls,
       combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
       combinedPayload.capsules.concat(options.capsules ?? []),
       combinedPayload.extraHashedArgs,
     );
-    const { fee: userFee, txNonce, cancellable } = options;
-    const fee = await this.getFeeOptions(requestWithoutFee, userFee, {});
-    const txRequest = await this.wallet.createTxExecutionRequest(requestWithoutFee, fee, {
-      txNonce,
-      cancellable,
-    });
 
-    const utilityCalls = utility.map(
-      async ([call, index]) =>
-        [
-          await this.wallet.simulateUtility(call.name, call.args, call.to, options?.authWitnesses, options?.from),
-          index,
-        ] as const,
-    );
+    const utilityBatchPromise =
+      utility.length > 0
+        ? this.wallet.batch(
+            utility.map(([call]) => ({
+              name: 'simulateUtility' as const,
+              args: [call.name, call.args, call.to, options?.authWitnesses] as const,
+            })),
+          )
+        : Promise.resolve([]);
 
-    const [utilityResults, simulatedTx] = await Promise.all([
-      Promise.all(utilityCalls),
-      this.wallet.simulateTx(txRequest, true, options?.skipTxValidation, false),
+    const [utilityBatchResults, simulatedTx] = await Promise.all([
+      utilityBatchPromise,
+      indexedExecutionPayloads.length > 0
+        ? this.wallet.simulateTx(executionPayload, await toSimulateOptions(options))
+        : Promise.resolve(),
     ]);
 
     const results: any[] = [];
 
-    utilityResults.forEach(([{ result }, index]) => {
-      results[index] = result;
+    utilityBatchResults.forEach((wrappedResult, utilityIndex) => {
+      const [, originalIndex] = utility[utilityIndex];
+      results[originalIndex] = wrappedResult.result.result;
     });
-    indexedExecutionPayloads.forEach(([request, callIndex, resultIndex]) => {
-      const call = request.calls[0];
-      // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
-      // since we're interested in the first set of values AFTER the account entrypoint
-      // For public functions we retrieve the first values directly from the public output.
-      const rawReturnValues =
-        call.type == FunctionType.PRIVATE
-          ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
-          : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
 
-      results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
-    });
+    if (simulatedTx) {
+      indexedExecutionPayloads.forEach(([request, callIndex, resultIndex]) => {
+        const call = request.calls[0];
+        // As account entrypoints are private, for private functions we retrieve the return values from the first nested call
+        // since we're interested in the first set of values AFTER the account entrypoint
+        // For public functions we retrieve the first values directly from the public output.
+        const rawReturnValues =
+          call.type == FunctionType.PRIVATE
+            ? simulatedTx.getPrivateReturnValues()?.nested?.[resultIndex].values
+            : simulatedTx.getPublicReturnValues()?.[resultIndex].values;
+
+        results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+      });
+    }
+
     return results;
   }
 
-  private async getRequests() {
-    return await Promise.all(this.calls.map(c => c.request()));
+  protected async getExecutionPayloads(): Promise<ExecutionPayload[]> {
+    return await Promise.all(this.interactions.map(i => (i instanceof ExecutionPayload ? i : i.request())));
   }
 }

package/src/contract/contract.ts

@@ -1,6 +1,5 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
 import type { Wallet } from '../wallet/wallet.js';
@@ -11,7 +10,7 @@ import { DeployMethod } from './deploy_method.js';
  * The Contract class represents a contract and provides utility methods for interacting with it.
  * It enables the creation of ContractFunctionInteraction instances for each function in the contract's ABI,
  * allowing users to call or send transactions to these functions. Additionally, the Contract class can be used
- * to attach the contract instance to a deployed contract on-chain through the PXE, which facilitates
+ * to attach the contract instance to a deployed contract onchain through the PXE, which facilitates
  * interaction with Aztec's privacy protocol.
  */
 export class Contract extends ContractBase {
@@ -23,16 +22,7 @@ export class Contract extends ContractBase {
    * @returns A promise that resolves to a new Contract instance.
    */
   public static async at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Promise<Contract> {
-    const instance = (await wallet.getContractMetadata(address)).contractInstance;
-    if (instance === undefined) {
-      throw new Error(`Contract instance at ${address.toString()} has not been registered in the wallet's PXE`);
-    }
-    const thisContractClass = await getContractClassFromArtifact(artifact);
-    if (!thisContractClass.id.equals(instance.currentContractClassId)) {
-      // wallet holds an outdated version of this contract
-      await wallet.updateContract(address, artifact);
-      instance.currentContractClassId = thisContractClass.id;
-    }
+    const instance = await wallet.registerContract(address, artifact);
     return new Contract(instance, artifact, wallet);
   }