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

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/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 './base_wallet.js';
+export * from './account_manager.js';

package/src/wallet/wallet.ts

@@ -0,0 +1,362 @@
+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 { 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 = {
+  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/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

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

@@ -1 +0,0 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/account/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,gBAAgB,GACnC,GAAG,GAAG;IACJ,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC7E,CAAC"}

package/dest/account/wallet.js

@@ -1,3 +0,0 @@
-/**
- * The wallet interface.
- */ export { };

package/dest/account_manager/deploy_account_method.d.ts

@@ -1,15 +0,0 @@
-import { type ContractArtifact, type FunctionArtifact } from '@aztec/stdlib/abi';
-import type { PublicKeys } from '@aztec/stdlib/keys';
-import type { AuthWitnessProvider } from '../account/interface.js';
-import type { Wallet } from '../account/wallet.js';
-import type { ExecutionRequestInit } from '../api/entrypoint.js';
-import { DeployMethod, type DeployOptions } from '../contract/deploy_method.js';
-/**
- * Contract interaction for deploying an account contract. Handles fee preparation and contract initialization.
- */
-export declare class DeployAccountMethod extends DeployMethod {
-    #private;
-    constructor(authWitnessProvider: AuthWitnessProvider, publicKeys: PublicKeys, wallet: Wallet, artifact: ContractArtifact, args?: any[], constructorNameOrArtifact?: string | FunctionArtifact, feePaymentNameOrArtifact?: string | FunctionArtifact);
-    protected getInitializeFunctionCalls(options: DeployOptions): Promise<Pick<ExecutionRequestInit, 'calls' | 'authWitnesses' | 'hashedArguments'>>;
-}
-//# sourceMappingURL=deploy_account_method.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"deploy_account_method.d.ts","sourceRoot":"","sources":["../../src/account_manager/deploy_account_method.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAItB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGhF;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,YAAY;;gBAKjD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,GAAE,GAAG,EAAO,EAChB,yBAAyB,CAAC,EAAE,MAAM,GAAG,gBAAgB,EACrD,wBAAwB,CAAC,EAAE,MAAM,GAAG,gBAAgB;cAkB7B,0BAA0B,CACjD,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,eAAe,GAAG,iBAAiB,CAAC,CAAC;CAmCtF"}

package/dest/account_manager/deploy_account_method.js

@@ -1,43 +0,0 @@
-import { FunctionSelector, encodeArguments, getFunctionArtifactByName } from '@aztec/stdlib/abi';
-import { Contract } from '../contract/contract.js';
-import { DeployMethod } from '../contract/deploy_method.js';
-import { EntrypointPayload, computeCombinedPayloadHash } from '../entrypoint/payload.js';
-/**
- * Contract interaction for deploying an account contract. Handles fee preparation and contract initialization.
- */ export class DeployAccountMethod extends DeployMethod {
-    #authWitnessProvider;
-    #feePaymentArtifact;
-    constructor(authWitnessProvider, publicKeys, wallet, artifact, args = [], constructorNameOrArtifact, feePaymentNameOrArtifact){
-        super(publicKeys, wallet, artifact, (address, wallet)=>Contract.at(address, artifact, wallet), args, constructorNameOrArtifact);
-        this.#authWitnessProvider = authWitnessProvider;
-        this.#feePaymentArtifact = typeof feePaymentNameOrArtifact === 'string' ? getFunctionArtifactByName(artifact, feePaymentNameOrArtifact) : feePaymentNameOrArtifact;
-    }
-    async getInitializeFunctionCalls(options) {
-        const exec = await super.getInitializeFunctionCalls(options);
-        if (options.fee && this.#feePaymentArtifact) {
-            const { address } = await this.getInstance();
-            const emptyAppPayload = await EntrypointPayload.fromAppExecution([]);
-            const fee = await this.getDefaultFeeOptions(options.fee);
-            const feePayload = await EntrypointPayload.fromFeeOptions(address, fee);
-            exec.calls.push({
-                name: this.#feePaymentArtifact.name,
-                to: address,
-                args: encodeArguments(this.#feePaymentArtifact, [
-                    emptyAppPayload,
-                    feePayload,
-                    false
-                ]),
-                selector: await FunctionSelector.fromNameAndParameters(this.#feePaymentArtifact.name, this.#feePaymentArtifact.parameters),
-                type: this.#feePaymentArtifact.functionType,
-                isStatic: this.#feePaymentArtifact.isStatic,
-                returnTypes: this.#feePaymentArtifact.returnTypes
-            });
-            exec.authWitnesses ??= [];
-            exec.hashedArguments ??= [];
-            exec.authWitnesses.push(await this.#authWitnessProvider.createAuthWit(await computeCombinedPayloadHash(emptyAppPayload, feePayload)));
-            exec.hashedArguments.push(...emptyAppPayload.hashedArguments);
-            exec.hashedArguments.push(...feePayload.hashedArguments);
-        }
-        return exec;
-    }
-}

package/dest/account_manager/deploy_account_sent_tx.d.ts

@@ -1,30 +0,0 @@
-import type { FieldsOf } from '@aztec/foundation/types';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { TxHash, TxReceipt } from '@aztec/stdlib/tx';
-import type { Wallet } from '../account/index.js';
-import { SentTx, type WaitOpts } from '../contract/sent_tx.js';
-/** Extends a transaction receipt with a wallet instance for the newly deployed contract. */
-export type DeployAccountTxReceipt = FieldsOf<TxReceipt> & {
-    /** Wallet that corresponds to the newly deployed account contract. */
-    wallet: Wallet;
-};
-/**
- * A deployment transaction for an account contract sent to the network, extending SentTx with methods to get the resulting wallet.
- */
-export declare class DeployAccountSentTx extends SentTx {
-    private getWalletPromise;
-    constructor(pxe: PXE, txHashPromise: Promise<TxHash>, getWalletPromise: Promise<Wallet>);
-    /**
-     * Awaits for the tx to be mined and returns the contract instance. Throws if tx is not mined.
-     * @param opts - Options for configuring the waiting for the tx to be mined.
-     * @returns The deployed contract instance.
-     */
-    getWallet(opts?: WaitOpts): Promise<Wallet>;
-    /**
-     * Awaits for the tx to be mined and returns the receipt along with a wallet instance. Throws if tx is not mined.
-     * @param opts - Options for configuring the waiting for the tx to be mined.
-     * @returns The transaction receipt with the wallet for the deployed account contract.
-     */
-    wait(opts?: WaitOpts): Promise<DeployAccountTxReceipt>;
-}
-//# sourceMappingURL=deploy_account_sent_tx.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"deploy_account_sent_tx.d.ts","sourceRoot":"","sources":["../../src/account_manager/deploy_account_sent_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAmB,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEhF,4FAA4F;AAC5F,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,SAAS,CAAC,GAAG;IACzD,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,MAAM;IACS,OAAO,CAAC,gBAAgB;gBAAlE,GAAG,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,EAAU,gBAAgB,EAAE,OAAO,CAAC,MAAM,CAAC;IAI/F;;;;OAIG;IACU,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAKxD;;;;OAIG;IACmB,IAAI,CAAC,IAAI,GAAE,QAA0B,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAK9F"}