@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/wallet/account_manager.ts

@@ -0,0 +1,154 @@
+import { Fr } from '@aztec/foundation/fields';
+import {
+  CompleteAddress,
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/stdlib/contract';
+import { deriveKeys } from '@aztec/stdlib/keys';
+
+import type { AccountContract } from '../account/account_contract.js';
+import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
+import type { Salt } from '../account/index.js';
+import type { AccountInterface } from '../account/interface.js';
+import { Contract } from '../contract/contract.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import type { Wallet } from './wallet.js';
+
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */
+export class AccountManager {
+  private constructor(
+    private wallet: Wallet,
+    private secretKey: Fr,
+    private accountContract: AccountContract,
+    private instance: ContractInstanceWithAddress,
+    /**
+     * Contract instantiation salt for the account contract
+     */
+    public readonly salt: Salt,
+  ) {}
+
+  static async create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, salt?: Salt) {
+    const { publicKeys } = await deriveKeys(secretKey);
+    salt = salt !== undefined ? new Fr(salt) : Fr.random();
+
+    const { constructorName, constructorArgs } = (await accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    const artifact = await accountContract.getContractArtifact();
+    const instance = await getContractInstanceFromInstantiationParams(artifact, {
+      constructorArtifact: constructorName,
+      constructorArgs,
+      salt: salt,
+      publicKeys,
+    });
+
+    return new AccountManager(wallet, secretKey, accountContract, instance, salt);
+  }
+
+  protected getPublicKeys() {
+    return this.instance.publicKeys;
+  }
+
+  protected getPublicKeysHash() {
+    return this.getPublicKeys().hash();
+  }
+
+  /**
+   * Returns the entrypoint for this account as defined by its account contract.
+   * @returns An entrypoint.
+   */
+  public async getAccountInterface(): Promise<AccountInterface> {
+    const chainInfo = await this.wallet.getChainInfo();
+    const completeAddress = await this.getCompleteAddress();
+    return this.accountContract.getInterface(completeAddress, chainInfo);
+  }
+
+  /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns The address, partial address, and encryption public key.
+   */
+  public getCompleteAddress(): Promise<CompleteAddress> {
+    return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+  }
+
+  /**
+   * Returns the secret key used to derive the rest of the privacy keys for this contract
+   */
+  public getSecretKey() {
+    return this.secretKey;
+  }
+
+  get address() {
+    return this.instance.address;
+  }
+
+  /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns ContractInstance instance.
+   */
+  public getInstance(): ContractInstanceWithAddress {
+    return this.instance;
+  }
+
+  /**
+   * Returns a Wallet instance associated with this account. Use it to create Contract
+   * instances to be interacted with from this account.
+   * @returns A Wallet instance.
+   */
+  public async getAccount(): Promise<AccountWithSecretKey> {
+    const accountInterface = await this.getAccountInterface();
+    return new AccountWithSecretKey(accountInterface, this.secretKey, this.salt);
+  }
+
+  /**
+   * Returns the account contract that backs this account.
+   * @returns The account contract
+   */
+  getAccountContract(): AccountContract {
+    return this.accountContract;
+  }
+
+  /**
+   * Returns a preconfigured deploy method that contains all the necessary function
+   * calls to deploy the account contract.
+   */
+  public async getDeployMethod(): Promise<DeployAccountMethod> {
+    const artifact = await this.accountContract.getContractArtifact();
+
+    if (!(await this.hasInitializer())) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
+      // there should be a path which enables an account contract's class & instance to be published,
+      // even if the account contract doesn't have an initializer function. This should not throw.
+      throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
+    }
+
+    const { constructorName, constructorArgs } = (await this.accountContract.getInitializationFunctionAndArgs()) ?? {
+      constructorName: undefined,
+      constructorArgs: undefined,
+    };
+
+    return new DeployAccountMethod(
+      this.getPublicKeys(),
+      this.wallet,
+      artifact,
+      instance => Contract.at(instance.address, artifact, this.wallet),
+      new Fr(this.salt),
+      constructorArgs,
+      constructorName,
+    );
+  }
+
+  /**
+   * Returns whether this account contract has an initializer function.
+   */
+  public async hasInitializer() {
+    return (await this.accountContract.getInitializationFunctionAndArgs()) !== undefined;
+  }
+}

package/src/wallet/deploy_account_method.ts

@@ -0,0 +1,126 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact, FunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
+
+import type { Contract } from '../contract/contract.js';
+import type { ContractBase } from '../contract/contract_base.js';
+import {
+  DeployMethod,
+  type DeployOptions,
+  type RequestDeployOptions,
+  type SimulateDeployOptions,
+} from '../contract/deploy_method.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+import { AccountEntrypointMetaPaymentMethod } from './account_entrypoint_meta_payment_method.js';
+import type { Wallet } from './index.js';
+
+/**
+ * The configuration options for the request method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type RequestDeployAccountOptions = Omit<RequestDeployOptions, 'contractAddressSalt'>;
+
+/**
+ * The configuration options for the send/prove methods. Omits:
+ * - The contractAddressSalt, since for account contracts that is fixed in the constructor.
+ * - UniversalDeployment flag, since account contracts are always deployed with it set to true
+ */
+export type DeployAccountOptions = Omit<DeployOptions, 'contractAddressSalt' | 'universalDeploy'>;
+
+/**
+ * The configuration options for the simulate method. Omits the contractAddressSalt, since
+ * for account contracts that is fixed in the constructor
+ */
+export type SimulateDeployAccountOptions = Omit<SimulateDeployOptions, 'contractAddressSalt'>;
+
+/**
+ * Modified version of the DeployMethod used to deploy account contracts. Supports deploying
+ * contracts that can pay for their own fee, plus some preconfigured options to avoid errors.
+ */
+export class DeployAccountMethod<TContract extends ContractBase = Contract> extends DeployMethod<TContract> {
+  constructor(
+    publicKeys: PublicKeys,
+    wallet: Wallet,
+    artifact: ContractArtifact,
+    postDeployCtor: (instance: ContractInstanceWithAddress, wallet: Wallet) => TContract,
+    private salt: Fr,
+    args: any[] = [],
+    constructorNameOrArtifact?: string | FunctionArtifact,
+  ) {
+    super(publicKeys, wallet, artifact, postDeployCtor, args, constructorNameOrArtifact);
+  }
+
+  /**
+   * Returns a FeePaymentMethod that routes the original one provided as an argument
+   * through the account's entrypoint. This allows an account contract to pay
+   * for its own deployment and initialization.
+   *
+   * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
+   *
+   * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+   * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
+   */
+  private getSelfFeePaymentMethod(originalPaymentMethod?: FeePaymentMethod) {
+    if (!this.address) {
+      throw new Error('Instance is not yet constructed. This is a bug!');
+    }
+    return new AccountEntrypointMetaPaymentMethod(
+      this.wallet,
+      this.artifact,
+      'entrypoint',
+      this.address,
+      originalPaymentMethod,
+    );
+  }
+
+  /**
+   * Returns the execution payload that allows this operation to happen on chain.
+   * @param opts - Configuration options.
+   * @returns The execution payload for this operation
+   */
+  public override async request(opts?: RequestDeployAccountOptions): Promise<ExecutionPayload> {
+    const optionsWithDefaults: RequestDeployOptions = {
+      ...opts,
+      // Regardless of whom sends the transaction, account contracts
+      // are always deployed as universalDeployment: true
+      deployer: undefined,
+      contractAddressSalt: new Fr(this.salt),
+      skipClassPublication: opts?.skipClassPublication ?? true,
+      skipInstancePublication: opts?.skipInstancePublication ?? true,
+      skipInitialization: opts?.skipInitialization ?? false,
+    };
+    // Override the fee to undefined, since we'll replace it
+    const deploymentExecutionPayload = await super.request({ ...optionsWithDefaults, fee: undefined });
+    const executionPayloads = [deploymentExecutionPayload];
+    // If this is a self-deployment, manage the fee accordingly
+    if (opts?.deployer?.equals(AztecAddress.ZERO)) {
+      const feePaymentMethod = this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod);
+      const feeExecutionPayload = await feePaymentMethod.getExecutionPayload();
+      // Notice they are reversed (fee payment usually goes first):
+      // this is because we need to construct the contract BEFORE it can pay for its own fee
+      executionPayloads.push(feeExecutionPayload);
+    } else {
+      const feeExecutionPayload = opts?.fee?.paymentMethod
+        ? await opts.fee.paymentMethod.getExecutionPayload()
+        : undefined;
+      if (feeExecutionPayload) {
+        executionPayloads.unshift(feeExecutionPayload);
+      }
+    }
+    return mergeExecutionPayloads(executionPayloads);
+  }
+
+  override convertDeployOptionsToRequestOptions(options: DeployOptions): RequestDeployOptions {
+    return {
+      ...options,
+      // Deployer is handled in the request method and forcibly set to undefined,
+      // since our account contracts are created with universalDeployment: true
+      // We need to forward it though, because depending on the deployer we have to assemble
+      // The fee payment method one way or another
+      deployer: options.from,
+    };
+  }
+}

package/src/wallet/index.ts

@@ -1,33 +1,2 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import type { AccountContract } from '../account/contract.js';
-import { AccountWallet } from './account_wallet.js';
-
-export * from '../account/wallet.js';
-export * from './account_wallet.js';
-export * from './account_wallet_with_private_key.js';
-export * from './signerless_wallet.js';
-
-/**
- * Gets a wallet for an already registered account.
- * @param pxe - PXE Service instance.
- * @param address - Address for the account.
- * @param accountContract - Account contract implementation.
- * @returns A wallet for this account that can be used to interact with a contract instance.
- */
-export async function getWallet(
-  pxe: PXE,
-  address: AztecAddress,
-  accountContract: AccountContract,
-): Promise<AccountWallet> {
-  const completeAddress = (await pxe.getRegisteredAccounts()).find(completeAddress =>
-    completeAddress.address.equals(address),
-  );
-  if (!completeAddress) {
-    throw new Error(`Account ${address} not found`);
-  }
-  const nodeInfo = await pxe.getNodeInfo();
-  const entrypoint = accountContract.getInterface(completeAddress, nodeInfo);
-  return new AccountWallet(pxe, entrypoint);
-}
+export * from './wallet.js';
+export * from './account_manager.js';

package/src/wallet/wallet.ts

@@ -0,0 +1,318 @@
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { Fr } from '@aztec/foundation/fields';
+import {
+  AbiTypeSchema,
+  type ContractArtifact,
+  ContractArtifactSchema,
+  type EventMetadataDefinition,
+  type FunctionCall,
+  FunctionType,
+} from '@aztec/stdlib/abi';
+import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassMetadata,
+  ContractClassWithIdSchema,
+  type ContractInstanceWithAddress,
+  ContractInstanceWithAddressSchema,
+  type ContractMetadata,
+} from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import { AbiDecodedSchema, type ApiSchemaFor, type ZodFor, optional, schemas } from '@aztec/stdlib/schemas';
+import {
+  Capsule,
+  HashedValues,
+  TxHash,
+  TxProfileResult,
+  TxReceipt,
+  TxSimulationResult,
+  UtilitySimulationResult,
+} from '@aztec/stdlib/tx';
+import type { ExecutionPayload } from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+import type {
+  FeeEstimationOptions,
+  GasSettingsOption,
+  ProfileInteractionOptions,
+  SendInteractionOptions,
+  SimulateInteractionOptions,
+} from '../contract/interaction_options.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+
+/**
+ * A wrapper type that allows any item to be associated with an alias.
+ */
+export type Aliased<T> = {
+  /**
+   * The alias
+   */
+  alias: string;
+  /**
+   * The item being aliased.
+   */
+  item: T;
+};
+
+/**
+ * Options for simulating interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type SimulateOptions = Omit<SimulateInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption & FeeEstimationOptions;
+};
+
+/**
+ * Options for profiling interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type ProfileOptions = Omit<ProfileInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption;
+};
+
+/**
+ * Options for sending/proving interactions with the wallet. Overrides the fee settings of an interaction with
+ * a simplified version that only hints at the wallet wether the interaction contains a
+ * fee payment method or not
+ */
+export type SendOptions = Omit<SendInteractionOptions, 'fee'> & {
+  /** The fee options */
+  fee?: GasSettingsOption;
+};
+
+/**
+ * Helper type that represents all methods that can be batched.
+ */
+export type BatchableMethods = Pick<
+  Wallet,
+  'registerContract' | 'sendTx' | 'registerSender' | 'simulateUtility' | 'simulateTx'
+>;
+
+/**
+ * From the batchable methods, we create a type that represents a method call with its name and arguments.
+ * This is what the wallet will accept as arguments to the `batch` method.
+ */
+export type BatchedMethod<T extends keyof BatchableMethods> = {
+  /** The method name */
+  name: T;
+  /** The method arguments */
+  args: Parameters<BatchableMethods[T]>;
+};
+
+/**
+ * Helper type to extract the return type of a batched method
+ */
+export type BatchedMethodResult<T> =
+  T extends BatchedMethod<infer K> ? Awaited<ReturnType<BatchableMethods[K]>> : never;
+
+/**
+ * Wrapper type for batch results that includes the method name for discriminated union deserialization.
+ * Each result is wrapped as \{ name: 'methodName', result: ActualResult \} to allow proper deserialization
+ * when AztecAddress and TxHash would otherwise be ambiguous (both are hex strings).
+ */
+export type BatchedMethodResultWrapper<T extends BatchedMethod<keyof BatchableMethods>> = {
+  /** The method name */
+  name: T['name'];
+  /** The method result */
+  result: BatchedMethodResult<T>;
+};
+
+/**
+ * Maps a tuple of BatchedMethod to a tuple of their wrapped return types
+ */
+export type BatchResults<T extends readonly BatchedMethod<keyof BatchableMethods>[]> = {
+  [K in keyof T]: BatchedMethodResultWrapper<T[K]>;
+};
+
+/**
+ * The wallet interface.
+ */
+export type Wallet = {
+  getContractClassMetadata(id: Fr, includeArtifact?: boolean): Promise<ContractClassMetadata>;
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
+  getPrivateEvents<T>(
+    contractAddress: AztecAddress,
+    eventMetadata: EventMetadataDefinition,
+    from: number,
+    numBlocks: number,
+    recipients: AztecAddress[],
+  ): Promise<T[]>;
+  getChainInfo(): Promise<ChainInfo>;
+  getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
+  registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress>;
+  getAddressBook(): Promise<Aliased<AztecAddress>[]>;
+  getAccounts(): Promise<Aliased<AztecAddress>[]>;
+  registerContract(
+    instance: ContractInstanceWithAddress,
+    artifact?: ContractArtifact,
+    secretKey?: Fr,
+  ): Promise<ContractInstanceWithAddress>;
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
+  simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult>;
+  profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
+  sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
+  createAuthWit(from: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent): Promise<AuthWitness>;
+  batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(methods: T): Promise<BatchResults<T>>;
+};
+
+export const FunctionCallSchema = z.object({
+  name: z.string(),
+  to: schemas.AztecAddress,
+  selector: schemas.FunctionSelector,
+  type: z.nativeEnum(FunctionType),
+  isStatic: z.boolean(),
+  hideMsgSender: z.boolean(),
+  args: z.array(schemas.Fr),
+  returnTypes: z.array(AbiTypeSchema),
+});
+
+export const ExecutionPayloadSchema = z.object({
+  calls: z.array(FunctionCallSchema),
+  authWitnesses: z.array(AuthWitness.schema),
+  capsules: z.array(Capsule.schema),
+  extraHashedArgs: z.array(HashedValues.schema),
+  feePayer: optional(schemas.AztecAddress),
+});
+
+export const GasSettingsOptionSchema = z.object({
+  gasSettings: optional(
+    z.object({
+      gasLimits: optional(Gas.schema),
+      teardownGasLimits: optional(Gas.schema),
+      maxFeePerGas: optional(z.object({ feePerDaGas: schemas.BigInt, feePerL2Gas: schemas.BigInt })),
+      maxPriorityFeePerGas: optional(z.object({ feePerDaGas: schemas.BigInt, feePerL2Gas: schemas.BigInt })),
+    }),
+  ),
+});
+
+export const WalletSimulationFeeOptionSchema = GasSettingsOptionSchema.extend({
+  estimatedGasPadding: optional(z.number()),
+  estimateGas: optional(z.boolean()),
+});
+
+export const SendOptionsSchema = z.object({
+  from: schemas.AztecAddress,
+  authWitnesses: optional(z.array(AuthWitness.schema)),
+  capsules: optional(z.array(Capsule.schema)),
+  fee: optional(GasSettingsOptionSchema),
+});
+
+export const SimulateOptionsSchema = z.object({
+  from: schemas.AztecAddress,
+  authWitnesses: optional(z.array(AuthWitness.schema)),
+  capsules: optional(z.array(Capsule.schema)),
+  fee: optional(WalletSimulationFeeOptionSchema),
+  skipTxValidation: optional(z.boolean()),
+  skipFeeEnforcement: optional(z.boolean()),
+  includeMetadata: optional(z.boolean()),
+});
+
+export const ProfileOptionsSchema = SimulateOptionsSchema.extend({
+  profileMode: z.enum(['gates', 'execution-steps', 'full']),
+  skipProofGeneration: optional(z.boolean()),
+});
+
+export const MessageHashOrIntentSchema = z.union([
+  schemas.Fr,
+  z.object({ consumer: schemas.AztecAddress, innerHash: schemas.Fr }),
+  z.object({
+    caller: schemas.AztecAddress,
+    call: FunctionCallSchema,
+  }),
+]);
+
+export const BatchedMethodSchema = z.union([
+  z.object({
+    name: z.literal('registerSender'),
+    args: z.tuple([schemas.AztecAddress, optional(z.string())]),
+  }),
+  z.object({
+    name: z.literal('registerContract'),
+    args: z.tuple([ContractInstanceWithAddressSchema, optional(ContractArtifactSchema), optional(schemas.Fr)]),
+  }),
+  z.object({
+    name: z.literal('sendTx'),
+    args: z.tuple([ExecutionPayloadSchema, SendOptionsSchema]),
+  }),
+  z.object({
+    name: z.literal('simulateUtility'),
+    args: z.tuple([FunctionCallSchema, optional(z.array(AuthWitness.schema))]),
+  }),
+  z.object({
+    name: z.literal('simulateTx'),
+    args: z.tuple([ExecutionPayloadSchema, SimulateOptionsSchema]),
+  }),
+]);
+
+export const ContractMetadataSchema = z.object({
+  contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
+  isContractInitialized: z.boolean(),
+  isContractPublished: z.boolean(),
+}) satisfies ZodFor<ContractMetadata>;
+
+export const ContractClassMetadataSchema = z.object({
+  contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
+  isContractClassPubliclyRegistered: z.boolean(),
+  artifact: z.union([ContractArtifactSchema, z.undefined()]),
+}) satisfies ZodFor<ContractClassMetadata>;
+
+export const EventMetadataDefinitionSchema = z.object({
+  eventSelector: schemas.EventSelector,
+  abiType: AbiTypeSchema,
+  fieldNames: z.array(z.string()),
+});
+
+export const WalletSchema: ApiSchemaFor<Wallet> = {
+  getChainInfo: z
+    .function()
+    .args()
+    .returns(z.object({ chainId: schemas.Fr, version: schemas.Fr })),
+  getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),
+  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
+  getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
+  getPrivateEvents: z
+    .function()
+    .args(schemas.AztecAddress, EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.AztecAddress))
+    .returns(z.array(AbiDecodedSchema)),
+  registerSender: z.function().args(schemas.AztecAddress, optional(z.string())).returns(schemas.AztecAddress),
+  getAddressBook: z
+    .function()
+    .args()
+    .returns(z.array(z.object({ alias: z.string(), item: schemas.AztecAddress }))),
+  getAccounts: z
+    .function()
+    .args()
+    .returns(z.array(z.object({ alias: z.string(), item: schemas.AztecAddress }))),
+  registerContract: z
+    .function()
+    .args(ContractInstanceWithAddressSchema, optional(ContractArtifactSchema), optional(schemas.Fr))
+    .returns(ContractInstanceWithAddressSchema),
+  simulateTx: z.function().args(ExecutionPayloadSchema, SimulateOptionsSchema).returns(TxSimulationResult.schema),
+  simulateUtility: z
+    .function()
+    .args(FunctionCallSchema, optional(z.array(AuthWitness.schema)))
+    .returns(UtilitySimulationResult.schema),
+  profileTx: z.function().args(ExecutionPayloadSchema, ProfileOptionsSchema).returns(TxProfileResult.schema),
+  sendTx: z.function().args(ExecutionPayloadSchema, SendOptionsSchema).returns(TxHash.schema),
+  createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
+  // @ts-expect-error - ApiSchemaFor cannot properly type generic methods with readonly arrays
+  batch: z
+    .function()
+    .args(z.array(BatchedMethodSchema))
+    .returns(
+      z.array(
+        z.discriminatedUnion('name', [
+          z.object({ name: z.literal('registerSender'), result: schemas.AztecAddress }),
+          z.object({ name: z.literal('registerContract'), result: ContractInstanceWithAddressSchema }),
+          z.object({ name: z.literal('sendTx'), result: TxHash.schema }),
+          z.object({ name: z.literal('simulateUtility'), result: UtilitySimulationResult.schema }),
+          z.object({ name: z.literal('simulateTx'), result: TxSimulationResult.schema }),
+        ]),
+      ),
+    ),
+};

package/dest/account/contract.d.ts

@@ -1,37 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { ContractArtifact } from '@aztec/stdlib/abi';
-import type { CompleteAddress, NodeInfo } from '@aztec/stdlib/contract';
-import type { AccountInterface, AuthWitnessProvider } from './interface.js';
-/**
- * An account contract instance. Knows its artifact, deployment arguments, how to create
- * transaction execution requests out of function calls, and how to authorize actions.
- */
-export interface AccountContract {
-    /**
-     * Returns the artifact of this account contract.
-     */
-    getContractArtifact(): Promise<ContractArtifact>;
-    /**
-     * Returns the deployment arguments for this instance, or undefined if this contract does not require deployment.
-     */
-    getDeploymentArgs(): Promise<any[] | undefined>;
-    /**
-     * Returns the account interface for this account contract given a deployment at the provided address.
-     * The account interface is responsible for assembling tx requests given requested function calls, and
-     * for creating signed auth witnesses given action identifiers (message hashes).
-     * @param address - Address where this account contract is deployed.
-     * @param nodeInfo - Info on the chain where it is deployed.
-     * @returns An account interface instance for creating tx requests and authorizing actions.
-     */
-    getInterface(address: CompleteAddress, nodeInfo: NodeInfo): AccountInterface;
-    /**
-     * Returns the auth witness provider for the given address.
-     * @param address - Address for which to create auth witnesses.
-     */
-    getAuthWitnessProvider(address: CompleteAddress): AuthWitnessProvider;
-}
-/**
- * Compute the address of an account contract from secret and salt.
- */
-export declare function getAccountContractAddress(accountContract: AccountContract, secret: Fr, salt: Fr): Promise<import("@aztec/stdlib/aztec-address").AztecAddress>;
-//# sourceMappingURL=contract.d.ts.map

package/dest/account/contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/account/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAIxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG5E;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEjD;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;IAEhD;;;;;;;OAOG;IACH,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,CAAC;IAE7E;;;OAGG;IACH,sBAAsB,CAAC,OAAO,EAAE,eAAe,GAAG,mBAAmB,CAAC;CACvE;AAGD;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,+DAUrG"}

package/dest/account/wallet.d.ts

@@ -1,11 +0,0 @@
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
-import type { AccountInterface } from './interface.js';
-/**
- * The wallet interface.
- */
-export type Wallet = AccountInterface & PXE & {
-    createAuthWit(intent: IntentInnerHash | IntentAction): Promise<AuthWitness>;
-};
-//# sourceMappingURL=wallet.d.ts.map