@aztec/aztec.js 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/contract/base_contract_interaction.ts

@@ -1,30 +1,16 @@
-import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { GasSettings } from '@aztec/stdlib/gas';
-import type { Capsule, TxExecutionRequest, TxProvingResult } from '@aztec/stdlib/tx';
-
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../entrypoint/entrypoint.js';
-import type { FeeOptions, UserFeeOptions } from '../entrypoint/payload.js';
-import { FeeJuicePaymentMethod } from '../fee/fee_juice_payment_method.js';
-import { getGasLimits } from './get_gas_limits.js';
-import { ProvenTx } from './proven_tx.js';
-import { SentTx } from './sent_tx.js';
-
-/**
- * Represents options for calling a (constrained) function in a contract.
- * Allows the user to specify the sender address and nonce for a transaction.
- */
-export type SendMethodOptions = {
-  /** Wether to skip the simulation of the public part of the transaction. */
-  skipPublicSimulation?: boolean;
-  /** The fee options for the transaction. */
-  fee?: UserFeeOptions;
-  /** Custom nonce to inject into the app payload of the transaction. Useful when trying to cancel an ongoing transaction by creating a new one with a higher fee */
-  nonce?: Fr;
-  /** Whether the transaction can be cancelled. If true, an extra nullifier will be emitted: H(nonce, GENERATOR_INDEX__TX_NULLIFIER) */
-  cancellable?: boolean;
-};
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { Capsule, ExecutionPayload, TxReceipt } from '@aztec/stdlib/tx';
+
+import type { Wallet } from '../wallet/wallet.js';
+import {
+  type InteractionWaitOptions,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
+  type SendReturn,
+  toSendOptions,
+} from './interaction_options.js';
 
 /**
  * Base class for an interaction with a contract, be it a deployment, a function call, or a batch.
@@ -33,160 +19,43 @@ export type SendMethodOptions = {
 export abstract class BaseContractInteraction {
   protected log = createLogger('aztecjs:contract_interaction');
 
-  private capsules: Capsule[] = [];
-
-  constructor(protected wallet: Wallet) {}
+  constructor(
+    protected wallet: Wallet,
+    protected authWitnesses: AuthWitness[] = [],
+    protected capsules: Capsule[] = [],
+  ) {}
 
   /**
-   * Create a transaction execution request ready to be simulated.
+   * 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 A transaction execution request.
-   */
-  public abstract create(options?: SendMethodOptions): Promise<TxExecutionRequest>;
-
-  /**
-   * 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> {
-    const txRequest = await this.create(options);
-    const txSimulationResult = await this.wallet.simulateTx(txRequest, !options.skipPublicSimulation, undefined, true);
-    return await this.wallet.proveTx(txRequest, txSimulationResult.privateExecutionResult);
-  }
-
-  // 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
+   * @returns An execution request wrapped in promise.
    */
-  public async prove(options: SendMethodOptions = {}): Promise<ProvenTx> {
-    // docs:end:prove
-    const txProvingResult = await this.proveInternal(options);
-    return new ProvenTx(this.wallet, txProvingResult.toTx());
-  }
+  public abstract request(options?: RequestInteractionOptions): Promise<ExecutionPayload>;
 
   // docs:start:send
   /**
    * Sends a transaction to the contract function with the specified options.
-   * This function throws an error if called on an unconstrained 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.
-   * @returns A SentTx instance for tracking the transaction status and information.
-   */
-  public send(options: SendMethodOptions = {}): SentTx {
+   * By default, waits for the transaction to be mined and returns the receipt (or custom type).
+   * @param options - An object containing 'from' property representing
+   * the AztecAddress of the sender, optional fee configuration, and optional wait settings
+   * @returns TReturn (if wait is undefined/WaitOpts) or TxHash (if wait is NO_WAIT)
+   */
+  // Overload for when wait is not specified at all - returns TReturn
+  public send<TReturn = TxReceipt>(options: SendInteractionOptionsWithoutWait): Promise<TReturn>;
+  // Generic overload for explicit wait values
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public send<TReturn = TxReceipt, W extends InteractionWaitOptions = undefined>(
+    options: SendInteractionOptions<W>,
+  ): Promise<SendReturn<W, TReturn>>;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  public async send<TReturn = TxReceipt>(
+    options: SendInteractionOptions<InteractionWaitOptions>,
+  ): Promise<SendReturn<typeof options.wait, TReturn>> {
     // docs:end:send
-    const promise = (async () => {
-      const txProvingResult = await this.proveInternal(options);
-      return this.wallet.sendTx(txProvingResult.toTx());
-    })();
-    return new SentTx(this.wallet, promise);
-  }
+    const executionPayload = await this.request(options);
+    const sendOptions = toSendOptions(options);
 
-  // docs:start:estimateGas
-  /**
-   * Estimates gas for a given tx request and returns gas limits for it.
-   * @param opts - Options.
-   * @param pad - Percentage to pad the suggested gas limits by, if empty, defaults to 10%.
-   * @returns Gas limits.
-   */
-  public async estimateGas(
-    opts?: Omit<SendMethodOptions, 'estimateGas' | 'skipPublicSimulation'>,
-  ): Promise<Pick<GasSettings, 'gasLimits' | 'teardownGasLimits'>> {
-    // docs:end:estimateGas
-    const txRequest = await this.create({ ...opts, fee: { ...opts?.fee, estimateGas: false } });
-    const simulationResult = await this.wallet.simulateTx(
-      txRequest,
-      true /*simulatePublic*/,
-      undefined /* msgSender */,
-      undefined /* skipTxValidation */,
-      true /* skipFeeEnforcement */,
-    );
-    const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
-      simulationResult,
-      opts?.fee?.estimatedGasPadding,
-    );
-    return { gasLimits, 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 request - Request to execute for this interaction.
-   * @param pad - Percentage to pad the suggested gas limits by, as decimal (e.g., 0.10 for 10%).
-   * @returns Fee options for the actual transaction.
-   */
-  protected async getFeeOptions(
-    request: Omit<ExecutionRequestInit, 'fee'> & { /** User-provided fee options */ fee?: UserFeeOptions },
-  ): Promise<FeeOptions> {
-    // docs:end:getFeeOptions
-    const defaultFeeOptions = await this.getDefaultFeeOptions(request.fee);
-    const paymentMethod = defaultFeeOptions.paymentMethod;
-    const maxFeesPerGas = defaultFeeOptions.gasSettings.maxFeesPerGas;
-    const maxPriorityFeesPerGas = defaultFeeOptions.gasSettings.maxPriorityFeesPerGas;
-
-    let gasSettings = defaultFeeOptions.gasSettings;
-    if (request.fee?.estimateGas) {
-      const feeForEstimation: FeeOptions = { paymentMethod, gasSettings };
-      const txRequest = await this.wallet.createTxExecutionRequest({ ...request, fee: feeForEstimation });
-      const simulationResult = await this.wallet.simulateTx(
-        txRequest,
-        true /*simulatePublic*/,
-        undefined /* msgSender */,
-        undefined /* skipTxValidation */,
-        true /* skipFeeEnforcement */,
-      );
-      const { totalGas: gasLimits, teardownGas: teardownGasLimits } = getGasLimits(
-        simulationResult,
-        request.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 };
-  }
-
-  /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsule - Data passed to oracle calls.
-   */
-  public addCapsule(capsule: Capsule) {
-    this.capsules.push(capsule);
-  }
-
-  /**
-   * Add data passed to the oracle calls during this contract interaction.
-   * @param capsules - Data passed to oracle calls.
-   */
-  public addCapsules(capsules: Capsule[]) {
-    this.capsules.push(...capsules);
-  }
-
-  /**
-   * Return all capsules added for this function interaction.
-   */
-  public getCapsules() {
-    return this.capsules;
+    return (await this.wallet.sendTx(executionPayload, sendOptions as any)) as SendReturn<typeof options.wait, TReturn>;
   }
 }

package/src/contract/batch_call.ts

@@ -1,95 +1,146 @@
 import { type FunctionCall, FunctionType, decodeFromAbi } from '@aztec/stdlib/abi';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import {
+  ExecutionPayload,
+  TxSimulationResult,
+  UtilitySimulationResult,
+  mergeExecutionPayloads,
+} from '@aztec/stdlib/tx';
 
-import type { Wallet } from '../account/index.js';
-import { BaseContractInteraction, type SendMethodOptions } from './base_contract_interaction.js';
-import type { SimulateMethodOptions } from './contract_function_interaction.js';
+import type { BatchedMethod, Wallet } from '../wallet/wallet.js';
+import { BaseContractInteraction } from './base_contract_interaction.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. */
+// docs:start:batch_call_class
 export class BatchCall extends BaseContractInteraction {
-  constructor(wallet: Wallet, protected calls: FunctionCall[]) {
+  constructor(
+    wallet: Wallet,
+    protected interactions: (BaseContractInteraction | ExecutionPayload)[],
+  ) {
     super(wallet);
   }
+  // docs:end:batch_call_class
 
   /**
-   * Create a transaction execution request that represents this batch, encoded and authenticated by the
-   * user's wallet, ready to be simulated.
-   * @param opts - An optional object containing additional configuration for the transaction.
-   * @returns A Promise that resolves to a transaction instance.
+   * 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 create(opts?: SendMethodOptions): Promise<TxExecutionRequest> {
-    const calls = this.calls;
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...opts });
-    return await this.wallet.createTxExecutionRequest({ calls, capsules, ...opts, fee });
+  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;
   }
 
   /**
-   * Simulate a transaction and get its return values
-   * Differs from prove in a few important ways:
-   * 1. It returns the values of the function execution
-   * 2. It supports `unconstrained`, `private` and `public` functions
-   *
-   * @param options - An optional object containing additional configuration for the transaction.
-   * @returns The result of the transaction as returned by the contract function.
+   * Simulates the batch, supporting private, public and utility functions. Although this is a single
+   * interaction with the wallet, private and public functions will be grouped into a single ExecutionPayload
+   * that the wallet will simulate as a single transaction. Utility function calls will simply be executed
+   * one by one.
+   * @param options - An optional object containing additional configuration for the interaction.
+   * @returns The results of all the interactions that make up the batch
    */
-  public async simulate(options: SimulateMethodOptions = {}): Promise<any> {
-    const { indexedCalls, unconstrained } = this.calls.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 */
       publicIndex: 0;
-      /** The public and private function calls in the batch */
-      indexedCalls: [FunctionCall, number, number][];
-      /** The unconstrained function calls in the batch. */
-      unconstrained: [FunctionCall, number][];
+      /** The public and private function execution requests in the batch */
+      indexedExecutionPayloads: [ExecutionPayload, number, number][];
+      /** The utility function calls in the batch. */
+      utility: [FunctionCall, number][];
     }>(
       (acc, current, index) => {
-        if (current.type === FunctionType.UNCONSTRAINED) {
-          acc.unconstrained.push([current, index]);
+        const call = current.calls[0];
+        if (call.type === FunctionType.UTILITY) {
+          acc.utility.push([call, index]);
         } else {
-          acc.indexedCalls.push([
+          acc.indexedExecutionPayloads.push([
             current,
             index,
-            current.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
+            call.type === FunctionType.PRIVATE ? acc.privateIndex++ : acc.publicIndex++,
           ]);
         }
         return acc;
       },
-      { indexedCalls: [], unconstrained: [], publicIndex: 0, privateIndex: 0 },
+      { indexedExecutionPayloads: [], utility: [], publicIndex: 0, privateIndex: 0 },
     );
 
-    const calls = indexedCalls.map(([call]) => call);
-    const capsules = this.getCapsules();
-    const fee = await this.getFeeOptions({ calls, capsules, ...options });
-    const txRequest = await this.wallet.createTxExecutionRequest({ calls, capsules, ...options, fee });
+    const batchRequests: BatchedMethod[] = [];
 
-    const unconstrainedCalls = unconstrained.map(
-      async ([call, index]) =>
-        [await this.wallet.simulateUnconstrained(call.name, call.args, call.to, options?.from), index] as const,
-    );
+    // Add utility calls to batch
+    for (const [call] of utility) {
+      batchRequests.push({
+        name: 'simulateUtility' as const,
+        args: [call, options?.authWitnesses],
+      });
+    }
+
+    // Add tx simulation to batch if there are any private/public calls
+    if (indexedExecutionPayloads.length > 0) {
+      const payloads = indexedExecutionPayloads.map(([request]) => request);
+      const combinedPayload = mergeExecutionPayloads(payloads);
+      const executionPayload = new ExecutionPayload(
+        combinedPayload.calls,
+        combinedPayload.authWitnesses.concat(options.authWitnesses ?? []),
+        combinedPayload.capsules.concat(options.capsules ?? []),
+        combinedPayload.extraHashedArgs,
+      );
 
-    const [unconstrainedResults, simulatedTx] = await Promise.all([
-      Promise.all(unconstrainedCalls),
-      this.wallet.simulateTx(txRequest, true, options?.from, options?.skipTxValidation),
-    ]);
+      batchRequests.push({
+        name: 'simulateTx' as const,
+        args: [executionPayload, toSimulateOptions(options)],
+      });
+    }
+
+    const batchResults = batchRequests.length > 0 ? await this.wallet.batch(batchRequests) : [];
 
     const results: any[] = [];
 
-    unconstrainedResults.forEach(([result, index]) => {
-      results[index] = result;
-    });
-    indexedCalls.forEach(([call, callIndex, resultIndex]) => {
-      // 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;
+    // Process utility results (they come first in batch results)
+    for (let i = 0; i < utility.length; i++) {
+      const [call, resultIndex] = utility[i];
+      const wrappedResult = batchResults[i];
+      if (wrappedResult.name === 'simulateUtility') {
+        const rawReturnValues = (wrappedResult.result as UtilitySimulationResult).result;
+        results[resultIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
+      }
+    }
+
+    // Process tx simulation result (it comes last if present)
+    if (indexedExecutionPayloads.length > 0) {
+      const txResultWrapper = batchResults[utility.length];
+      if (txResultWrapper.name === 'simulateTx') {
+        const simulatedTx = txResultWrapper.result as TxSimulationResult;
+        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) : [];
+        });
+      }
+    }
 
-      results[callIndex] = rawReturnValues ? decodeFromAbi(call.returnTypes, rawReturnValues) : [];
-    });
     return results;
   }
+
+  protected async getExecutionPayloads(): Promise<ExecutionPayload[]> {
+    return await Promise.all(this.interactions.map(i => (i instanceof ExecutionPayload ? i : i.request())));
+  }
 }

package/src/contract/checker.ts

@@ -1,4 +1,10 @@
-import type { AbiType, BasicType, ContractArtifact, StructType } from '@aztec/stdlib/abi';
+import {
+  type AbiType,
+  type BasicType,
+  type ContractArtifact,
+  type StructType,
+  getDefaultInitializer,
+} from '@aztec/stdlib/abi';
 
 /**
  * Represents a type derived from input type T with the 'kind' property removed.
@@ -38,8 +44,7 @@ export function abiChecker(artifact: ContractArtifact) {
     });
   });
 
-  // TODO: implement a better check for constructor (right now only checks if it has it or not)
-  if (!artifact.functions.find(func => func.name === 'constructor')) {
+  if (!getDefaultInitializer(artifact)) {
     throw new Error('ABI has no constructor');
   }
 

package/src/contract/contract.ts

@@ -1,9 +1,9 @@
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { PublicKeys } from '@aztec/stdlib/keys';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractBase } from './contract_base.js';
 import { DeployMethod } from './deploy_method.js';
 
@@ -11,45 +11,37 @@ 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 {
   /**
-   * Creates a contract instance.
-   * @param address - The deployed contract's address.
+   * Gets a contract instance.
+   * @param address - The address of the contract instance.
    * @param artifact - Build artifact of the contract.
    * @param wallet - The wallet to use when interacting with the contract.
    * @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;
-    }
-    return new Contract(instance, artifact, wallet);
+  public static at(address: AztecAddress, artifact: ContractArtifact, wallet: Wallet): Contract {
+    return new Contract(address, artifact, wallet);
   }
 
   /**
-   * Creates a tx to deploy a new instance of a contract.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract to deploy
    * @param args - Arguments for the constructor.
    * @param constructorName - The name of the constructor function to call.
    */
   public static deploy(wallet: Wallet, artifact: ContractArtifact, args: any[], constructorName?: string) {
-    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, artifact, wallet);
+    const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
+      Contract.at(instance.address, artifact, wallet);
     return new DeployMethod(PublicKeys.default(), wallet, artifact, postDeployCtor, args, constructorName);
   }
 
   /**
-   * Creates a tx to deploy a new instance of a contract using the specified public keys hash to derive the address.
+   * Creates a tx to deploy (initialize and/or publish) a new instance of a contract
+   * using the specified public keys hash to derive the address.
    * @param publicKeys - Hash of public keys to use for deriving the address.
    * @param wallet - The wallet for executing the deployment.
    * @param artifact - Build artifact of the contract.
@@ -63,7 +55,8 @@ export class Contract extends ContractBase {
     args: any[],
     constructorName?: string,
   ) {
-    const postDeployCtor = (address: AztecAddress, wallet: Wallet) => Contract.at(address, artifact, wallet);
+    const postDeployCtor = (instance: ContractInstanceWithAddress, wallet: Wallet) =>
+      Contract.at(instance.address, artifact, wallet);
     return new DeployMethod(publicKeys, wallet, artifact, postDeployCtor, args, constructorName);
   }
 }

package/src/contract/contract_base.ts

@@ -1,13 +1,13 @@
 import {
   type ContractArtifact,
-  type ContractNote,
   type FieldLayout,
-  type FunctionArtifact,
+  type FunctionAbi,
   FunctionSelector,
+  getAllFunctionAbis,
 } from '@aztec/stdlib/abi';
-import { type ContractInstanceWithAddress, computePartialAddress } from '@aztec/stdlib/contract';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { Wallet } from '../account/index.js';
+import type { Wallet } from '../wallet/wallet.js';
 import { ContractFunctionInteraction } from './contract_function_interaction.js';
 
 /**
@@ -28,13 +28,6 @@ export type ContractStorageLayout<T extends string> = {
   [K in T]: FieldLayout;
 };
 
-/**
- * Type representing the notes used in a contract.
- */
-export type ContractNotes<T extends string> = {
-  [K in T]: ContractNote;
-};
-
 /**
  * Abstract implementation of a contract extended by the Contract class and generated contract types.
  */
@@ -45,16 +38,16 @@ export class ContractBase {
   public methods: { [name: string]: ContractMethod } = {};
 
   protected constructor(
-    /** The deployed contract instance definition. */
-    public readonly instance: ContractInstanceWithAddress,
+    /** The contract's address. */
+    public readonly address: AztecAddress,
     /** The Application Binary Interface for the contract. */
     public readonly artifact: ContractArtifact,
     /** The wallet used for interacting with this contract. */
     public wallet: Wallet,
   ) {
-    artifact.functions.forEach((f: FunctionArtifact) => {
+    getAllFunctionAbis(artifact).forEach((f: FunctionAbi) => {
       const interactionFunction = (...args: any[]) => {
-        return new ContractFunctionInteraction(this.wallet, this.instance.address, f, args);
+        return new ContractFunctionInteraction(this.wallet, this.address, f, args);
       };
 
       this.methods[f.name] = Object.assign(interactionFunction, {
@@ -69,22 +62,12 @@ export class ContractBase {
     });
   }
 
-  /** Address of the contract. */
-  public get address() {
-    return this.instance.address;
-  }
-
-  /** Partial address of the contract. */
-  public get partialAddress() {
-    return computePartialAddress(this.instance);
-  }
-
   /**
    * Creates a new instance of the contract wrapper attached to a different wallet.
    * @param wallet - Wallet to use for sending txs.
    * @returns A new contract instance.
    */
   public withWallet(wallet: Wallet): this {
-    return new ContractBase(this.instance, this.artifact, wallet) as this;
+    return new ContractBase(this.address, this.artifact, wallet) as this;
   }
 }