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

package/src/wallet/deploy_account_method.ts

@@ -0,0 +1,125 @@
+import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/entrypoints/payload';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact, FunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+
+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: (address: AztecAddress, wallet: Wallet) => Promise<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,3 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-
-import type { AccountContract } from '../account/account_contract.js';
-import { AccountWallet } from './account_wallet.js';
-
 export * from './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 './base_wallet.js';
+export * from './account_manager.js';

package/src/wallet/wallet.ts

@@ -1,34 +1,362 @@
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { ExecutionPayload } from '@aztec/entrypoints/payload';
+import type { Fr } from '@aztec/foundation/fields';
+import {
+  AbiTypeSchema,
+  type ContractArtifact,
+  ContractArtifactSchema,
+  type EventMetadataDefinition,
+  FunctionAbiSchema,
+  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 ContractInstantiationData,
+  type ContractMetadata,
+} from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import { PublicKeys } from '@aztec/stdlib/keys';
+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 { AccountInterface } from '../account/interface.js';
-import type { IntentAction, IntentInnerHash } from '../utils/authwit.js';
+import { z } from 'zod';
+
+import type { Contract } from '../contract/contract.js';
+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;
+};
+
+/**
+ * A reduced representation of a Contract, only including its instance and artifact
+ */
+export type ContractInstanceAndArtifact = Pick<Contract, 'artifact' | 'instance'>;
+
+/**
+ * Options that can be provided to the wallet for configuration of the fee payment.
+ */
+export type UserFeeOptions = {
+  /**
+   * Informs the wallet that the crafted tx already contains the necessary calls to pay for its fee
+   * and who is paying
+   */
+  embeddedPaymentMethodFeePayer?: AztecAddress;
+} & GasSettingsOption;
+
+/**
+ * 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?: UserFeeOptions & 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?: UserFeeOptions;
+};
+
+/**
+ * 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?: UserFeeOptions;
+};
+
+/**
+ * Helper type that represents all methods that can be batched.
+ */
+export type BatchableMethods = Pick<Wallet, 'registerContract' | 'sendTx' | 'registerSender' | 'simulateUtility'>;
+
+/**
+ * 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 = AccountInterface &
-  Pick<
-    PXE,
-    | 'simulateTx'
-    | 'simulateUtility'
-    | 'profileTx'
-    | 'sendTx'
-    | 'getContractClassMetadata'
-    | 'getContractMetadata'
-    | 'registerContract'
-    | 'registerContractClass'
-    | 'proveTx'
-    | 'getNodeInfo'
-    | 'getPXEInfo'
-    | 'getCurrentBaseFees'
-    | 'updateContract'
-    | 'registerSender'
-    | 'getSenders'
-    | 'removeSender'
-    | 'getTxReceipt'
-    | 'getPrivateEvents'
-    | 'getPublicEvents'
-  > & {
-    createAuthWit(intent: IntentInnerHash | IntentAction): Promise<AuthWitness>;
-  };
+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(
+    instanceData: AztecAddress | ContractInstanceWithAddress | ContractInstantiationData | ContractInstanceAndArtifact,
+  ): Promise<ContractInstanceWithAddress>;
+  // Overloaded definition to avoid zod issues
+  registerContract(
+    instanceData: AztecAddress | ContractInstanceWithAddress | ContractInstantiationData | ContractInstanceAndArtifact,
+    artifact: ContractArtifact,
+  ): Promise<ContractInstanceWithAddress>;
+  registerContract(
+    instanceData: AztecAddress | ContractInstanceWithAddress | ContractInstantiationData | ContractInstanceAndArtifact,
+    artifact: ContractArtifact | undefined,
+    secretKey: Fr | undefined,
+  ): Promise<ContractInstanceWithAddress>;
+  simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
+  simulateUtility(
+    functionName: string,
+    args: any[],
+    to: AztecAddress,
+    authwits?: AuthWitness[],
+  ): Promise<UtilitySimulationResult>;
+  profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
+  sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
+  createAuthWit(
+    from: AztecAddress,
+    messageHashOrIntent: Fr | Buffer<ArrayBuffer> | IntentInnerHash | CallIntent,
+  ): Promise<AuthWitness>;
+  batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(methods: T): Promise<BatchResults<T>>;
+};
+
+export const ContractInstantiationDataSchema = z.object({
+  constructorArtifact: optional(z.union([FunctionAbiSchema, z.string()])),
+  constructorArgs: optional(z.array(z.any())),
+  skipArgsDecoding: optional(z.boolean()),
+  salt: schemas.Fr,
+  publicKeys: optional(PublicKeys.schema),
+  deployer: optional(schemas.AztecAddress),
+});
+
+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),
+});
+
+export const UserFeeOptionsSchema = 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 })),
+    }),
+  ),
+  embeddedPaymentMethodFeePayer: optional(schemas.AztecAddress),
+});
+
+export const WalletSimulationFeeOptionSchema = UserFeeOptionsSchema.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(UserFeeOptionsSchema),
+});
+
+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 InstanceDataSchema = z.union([
+  schemas.AztecAddress,
+  ContractInstanceWithAddressSchema,
+  ContractInstantiationDataSchema,
+  z.object({ instance: ContractInstanceWithAddressSchema, artifact: ContractArtifactSchema }),
+]);
+
+export const MessageHashOrIntentSchema = z.union([
+  schemas.Fr,
+  schemas.Buffer,
+  z.object({ consumer: schemas.AztecAddress, innerHash: z.union([schemas.Buffer, 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([InstanceDataSchema, 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([z.string(), z.array(z.any()), schemas.AztecAddress, optional(z.array(AuthWitness.schema))]),
+  }),
+]);
+
+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(InstanceDataSchema, optional(ContractArtifactSchema), optional(schemas.Fr))
+    .returns(ContractInstanceWithAddressSchema),
+  simulateTx: z.function().args(ExecutionPayloadSchema, SimulateOptionsSchema).returns(TxSimulationResult.schema),
+  simulateUtility: z
+    .function()
+    .args(z.string(), z.array(z.any()), schemas.AztecAddress, 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 }),
+        ]),
+      ),
+    ),
+};

package/dest/account_manager/account_manager.d.ts

@@ -1,119 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { AccountContract } from '../account/account_contract.js';
-import type { Salt } from '../account/index.js';
-import type { AccountInterface } from '../account/interface.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-import { type WaitOpts } from '../contract/sent_tx.js';
-import { AccountEntrypointMetaPaymentMethod } from '../fee/account_entrypoint_meta_payment_method.js';
-import { AztecAddress, type FeePaymentMethod } from '../index.js';
-import { AccountWalletWithSecretKey, type Wallet } from '../wallet/index.js';
-import { DeployAccountSentTx } from './deploy_account_sent_tx.js';
-/**
- * Options to deploy an account contract.
- */
-export type DeployAccountOptions = Pick<DeployOptions, 'fee' | 'skipClassPublication' | 'skipInstancePublication' | 'skipInitialization'> & {
-    /**
-     * Wallet used for any txs to initialize and/or publish the account contract. Must be funded in order to pay for the fee.
-     */
-    deployWallet?: Wallet;
-};
-/**
- * Manages a user account. Provides methods for calculating the account's address, deploying the account contract,
- * and creating and registering the user wallet in the PXE Service.
- */
-export declare class AccountManager {
-    private pxe;
-    private secretKey;
-    private accountContract;
-    private instance;
-    /**
-     * Contract instantiation salt for the account contract
-     */
-    readonly salt: Salt;
-    private constructor();
-    static create(pxe: PXE, secretKey: Fr, accountContract: AccountContract, salt?: Salt): Promise<AccountManager>;
-    protected getPublicKeys(): import("@aztec/stdlib/keys").PublicKeys;
-    protected getPublicKeysHash(): Fr | Promise<Fr>;
-    /**
-     * Returns the entrypoint for this account as defined by its account contract.
-     * @returns An entrypoint.
-     */
-    getAccount(): Promise<AccountInterface>;
-    /**
-     * 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.
-     */
-    getCompleteAddress(): Promise<CompleteAddress>;
-    /**
-     * Gets the address for this given account.
-     * Does not require the account to have been published for public execution.
-     * @returns The address.
-     */
-    getAddress(): AztecAddress;
-    /**
-     * Returns the contract instance definition associated with this account.
-     * Does not require the account to have been published for public execution.
-     * @returns ContractInstance instance.
-     */
-    getInstance(): ContractInstanceWithAddress;
-    /**
-     * 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.
-     */
-    getWallet(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Add this account in the PXE Service and returns the associated wallet. Adding
-     * the account to the PXE Service is required for managing private state associated with it.
-     * Use the returned wallet to create Contract instances to be interacted with from this account.
-     * @param opts - Options to wait for the account to be synched.
-     * @returns A Wallet instance.
-     */
-    register(): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns the pre-populated ContractSetupMethods which can prepare a tx to
-     * initialize and/or publish this account's account contract (depending on the contract's design).
-     * If no wallet is provided, it uses a signerless wallet with the multi call entrypoint
-     * @param deployWallet - Wallet used for any txs that are needed to
-     * set up the account contract for use.
-     * @returns A ContractSetupMethods instance that can set up this account contract for use
-     */
-    getDeployMethod(deployWallet?: Wallet): Promise<DeployMethod>;
-    /**
-     * 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)
-     */
-    getSelfPaymentMethod(originalPaymentMethod?: FeePaymentMethod): Promise<AccountEntrypointMetaPaymentMethod>;
-    /**
-     * Submits a tx to initialize and/or publish this account's account contract
-     * (depending on the contract's design).
-     * Doesn't necessarily publish the class nor publish the instance.
-     * Uses the salt provided in the constructor or a randomly generated one.
-     * Adds the account to the PXE Service first.
-     * @param opts - Fee options to be used for the deployment.
-     * @returns A SentTx object that can be waited to get the associated Wallet.
-     */
-    deploy(opts?: DeployAccountOptions): DeployAccountSentTx;
-    /**
-     * Deploys the account contract that backs this account if needed and awaits the tx to be mined.
-     * Uses the salt provided in the constructor or a randomly generated one. If no initialization
-     * is required it skips the transaction, and only registers the account in the PXE Service.
-     * @param opts - Options to wait for the tx to be mined.
-     * @returns A Wallet instance.
-     */
-    waitSetup(opts?: DeployAccountOptions & WaitOpts): Promise<AccountWalletWithSecretKey>;
-    /**
-     * Returns whether this account contract has an initializer function.
-     */
-    hasInitializer(): Promise<boolean>;
-}
-//# sourceMappingURL=account_manager.d.ts.map

package/dest/account_manager/account_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"account_manager.d.ts","sourceRoot":"","sources":["../../src/account_manager/account_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,kCAAkC,EAAE,MAAM,kDAAkD,CAAC;AACtG,OAAO,EAAE,YAAY,EAAyB,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACzF,OAAO,EAAE,0BAA0B,EAAoB,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,aAAa,EACb,KAAK,GAAG,sBAAsB,GAAG,yBAAyB,GAAG,oBAAoB,CAClF,GAAG;IACF;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAChB;;OAEG;aACa,IAAI,EAAE,IAAI;IAR5B,OAAO;WAWM,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,IAAI;IAoB1F,SAAS,CAAC,aAAa;IAIvB,SAAS,CAAC,iBAAiB;IAI3B;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAMpD;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC;IAIrD;;;;OAIG;IACI,UAAU;IAIjB;;;;OAIG;IACI,WAAW,IAAI,2BAA2B;IAIjD;;;;OAIG;IACU,SAAS,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAK7D;;;;;;OAMG;IACU,QAAQ,IAAI,OAAO,CAAC,0BAA0B,CAAC;IAW5D;;;;;;;OAOG;IACU,eAAe,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAgD1E;;;;;;;;;OASG;IACU,oBAAoB,CAAC,qBAAqB,CAAC,EAAE,gBAAgB;IAa1E;;;;;;;;OAQG;IACI,MAAM,CAAC,IAAI,CAAC,EAAE,oBAAoB,GAAG,mBAAmB;IA6B/D;;;;;;OAMG;IACU,SAAS,CAAC,IAAI,GAAE,oBAAoB,GAAG,QAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAKpH;;OAEG;IACU,cAAc;CAG5B"}