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

package/src/wallet/wallet.ts

@@ -0,0 +1,533 @@
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import { BlockNumber, BlockNumberPositiveSchema } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  type AbiDecoded,
+  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 ContractInstanceWithAddress, ContractInstanceWithAddressSchema } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import { AbiDecodedSchema, type ApiSchemaFor, optional, schemas, zodFor } from '@aztec/stdlib/schemas';
+import type { ExecutionPayload, InTx } from '@aztec/stdlib/tx';
+import {
+  Capsule,
+  HashedValues,
+  TxHash,
+  TxProfileResult,
+  TxReceipt,
+  TxSimulationResult,
+  UtilitySimulationResult,
+  inTxSchema,
+} from '@aztec/stdlib/tx';
+
+import { z } from 'zod';
+
+import {
+  type FeeEstimationOptions,
+  type GasSettingsOption,
+  type InteractionWaitOptions,
+  NO_WAIT,
+  type ProfileInteractionOptions,
+  type SendInteractionOptionsWithoutWait,
+  type SendReturn,
+  type SimulateInteractionOptions,
+} from '../contract/interaction_options.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type { AppCapabilities, WalletCapabilities } from './capabilities.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 whether 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 whether 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 whether the interaction contains a
+ * fee payment method or not
+ */
+export type SendOptions<W extends InteractionWaitOptions = undefined> = Omit<
+  SendInteractionOptionsWithoutWait,
+  'fee'
+> & {
+  /** The fee options */
+  fee?: GasSettingsOption;
+  /** Whether to wait for the transaction to be mined */
+  wait?: W;
+};
+
+/**
+ * Helper type that represents all methods that can be batched (all methods except batch itself).
+ */
+export type BatchableMethods = Omit<Wallet, 'batch'>;
+
+/**
+ * A method call with its name and arguments.
+ */
+type BatchedMethodInternal<T extends keyof BatchableMethods> = {
+  /** The method name */
+  name: T;
+  /** The method arguments */
+  args: Parameters<BatchableMethods[T]>;
+};
+
+/**
+ * Union of all possible batched method calls.
+ * This ensures type safety: the `args` must match the specific `name`.
+ */
+export type BatchedMethod = {
+  [K in keyof BatchableMethods]: BatchedMethodInternal<K>;
+}[keyof BatchableMethods];
+
+/**
+ * Helper type to extract the return type of a batched method
+ */
+export type BatchedMethodResult<T> =
+  T extends BatchedMethodInternal<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> = {
+  /** 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[]> = {
+  [K in keyof T]: BatchedMethodResultWrapper<T[K]>;
+};
+
+/**
+ * Filter options when querying private events.
+ */
+export type PrivateEventFilter = {
+  /** The address of the contract that emitted the events. */
+  contractAddress: AztecAddress;
+  /** Addresses of accounts that are in scope for this filter. */
+  scopes: AztecAddress[];
+  /** Transaction in which the events were emitted. */
+  txHash?: TxHash;
+  /** The block number from which to start fetching events (inclusive).
+   * Optional. If provided, it must be greater or equal than 1.
+   * Defaults to the initial L2 block number (INITIAL_L2_BLOCK_NUM).
+   * */
+  fromBlock?: BlockNumber;
+  /** The block number until which to fetch logs (not inclusive).
+   * Optional. If provided, it must be greater than fromBlock.
+   * Defaults to the latest known block to PXE + 1.
+   */
+  toBlock?: BlockNumber;
+};
+
+/**
+ * An ABI decoded private event with associated metadata.
+ */
+export type PrivateEvent<T> = {
+  /** The ABI decoded event */
+  event: T;
+  /** Metadata describing event context information such as tx and block */
+  metadata: InTx;
+};
+
+/**
+ * Contract metadata including deployment and registration status.
+ */
+export type ContractMetadata = {
+  /** The contract instance */
+  instance?: ContractInstanceWithAddress;
+  /** Whether the contract has been initialized (init nullifier exists) */
+  isContractInitialized: boolean;
+  /** Whether the contract instance is publicly deployed on-chain */
+  isContractPublished: boolean;
+  /** Whether the contract has been updated to a different class */
+  isContractUpdated: boolean;
+  /** The updated contract class ID if the contract has been updated */
+  updatedContractClassId?: Fr | undefined;
+};
+
+/**
+ * Contract class metadata.
+ */
+export type ContractClassMetadata = {
+  /** Whether the artifact is registered in the wallet */
+  isArtifactRegistered: boolean;
+  /** Whether the contract class is publicly registered on-chain */
+  isContractClassPubliclyRegistered: boolean;
+};
+
+/**
+ * The wallet interface.
+ */
+export type Wallet = {
+  getPrivateEvents<T>(
+    eventMetadata: EventMetadataDefinition,
+    eventFilter: PrivateEventFilter,
+  ): Promise<PrivateEvent<T>[]>;
+  getChainInfo(): Promise<ChainInfo>;
+  getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
+  getContractClassMetadata(id: Fr): Promise<ContractClassMetadata>;
+  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<W extends InteractionWaitOptions = undefined>(
+    exec: ExecutionPayload,
+    opts: SendOptions<W>,
+  ): Promise<SendReturn<W>>;
+  createAuthWit(from: AztecAddress, messageHashOrIntent: IntentInnerHash | CallIntent): Promise<AuthWitness>;
+  requestCapabilities(manifest: AppCapabilities): Promise<WalletCapabilities>;
+  batch<const T extends readonly BatchedMethod[]>(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 WaitOptsSchema = z.object({
+  ignoreDroppedReceiptsFor: optional(z.number()),
+  timeout: optional(z.number()),
+  interval: optional(z.number()),
+  dontThrowOnRevert: 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),
+  wait: optional(z.union([z.literal(NO_WAIT), WaitOptsSchema])),
+});
+
+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([
+  z.object({ consumer: schemas.AztecAddress, innerHash: schemas.Fr }),
+  z.object({
+    caller: schemas.AztecAddress,
+    call: FunctionCallSchema,
+  }),
+]);
+
+export const EventMetadataDefinitionSchema = z.object({
+  eventSelector: schemas.EventSelector,
+  abiType: AbiTypeSchema,
+  fieldNames: z.array(z.string()),
+});
+
+export const PrivateEventSchema: z.ZodType<any> = zodFor<PrivateEvent<AbiDecoded>>()(
+  z.object({
+    event: AbiDecodedSchema,
+    metadata: inTxSchema(),
+  }),
+);
+
+export const PrivateEventFilterSchema = z.object({
+  contractAddress: schemas.AztecAddress,
+  scopes: z.array(schemas.AztecAddress),
+  txHash: optional(TxHash.schema),
+  fromBlock: optional(BlockNumberPositiveSchema),
+  toBlock: optional(BlockNumberPositiveSchema),
+});
+
+export const ContractMetadataSchema = z.object({
+  instance: optional(ContractInstanceWithAddressSchema),
+  isContractInitialized: z.boolean(),
+  isContractPublished: z.boolean(),
+  isContractUpdated: z.boolean(),
+  updatedContractClassId: optional(schemas.Fr),
+});
+
+export const ContractClassMetadataSchema = z.object({
+  isArtifactRegistered: z.boolean(),
+  isContractClassPubliclyRegistered: z.boolean(),
+});
+
+export const ContractFunctionPatternSchema = z.object({
+  contract: z.union([schemas.AztecAddress, z.literal('*')]),
+  function: z.union([z.string(), z.literal('*')]),
+});
+
+export const AccountsCapabilitySchema = z.object({
+  type: z.literal('accounts'),
+  canGet: optional(z.boolean()),
+  canCreateAuthWit: optional(z.boolean()),
+});
+
+export const GrantedAccountsCapabilitySchema = AccountsCapabilitySchema.extend({
+  accounts: z.array(z.object({ alias: z.string(), item: schemas.AztecAddress })),
+});
+
+export const ContractsCapabilitySchema = z.object({
+  type: z.literal('contracts'),
+  contracts: z.union([z.literal('*'), z.array(schemas.AztecAddress)]),
+  canRegister: optional(z.boolean()),
+  canGetMetadata: optional(z.boolean()),
+});
+
+export const GrantedContractsCapabilitySchema = ContractsCapabilitySchema;
+
+export const ContractClassesCapabilitySchema = z.object({
+  type: z.literal('contractClasses'),
+  classes: z.union([z.literal('*'), z.array(schemas.Fr)]),
+  canGetMetadata: z.boolean(),
+});
+
+export const GrantedContractClassesCapabilitySchema = ContractClassesCapabilitySchema;
+
+export const SimulationCapabilitySchema = z.object({
+  type: z.literal('simulation'),
+  transactions: optional(
+    z.object({
+      scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+    }),
+  ),
+  utilities: optional(
+    z.object({
+      scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+    }),
+  ),
+});
+
+export const GrantedSimulationCapabilitySchema = SimulationCapabilitySchema;
+
+export const TransactionCapabilitySchema = z.object({
+  type: z.literal('transaction'),
+  scope: z.union([z.literal('*'), z.array(ContractFunctionPatternSchema)]),
+});
+
+export const GrantedTransactionCapabilitySchema = TransactionCapabilitySchema;
+
+export const DataCapabilitySchema = z.object({
+  type: z.literal('data'),
+  addressBook: optional(z.boolean()),
+  privateEvents: optional(
+    z.object({
+      contracts: z.union([z.literal('*'), z.array(schemas.AztecAddress)]),
+    }),
+  ),
+});
+
+export const GrantedDataCapabilitySchema = DataCapabilitySchema;
+
+export const CapabilitySchema = z.discriminatedUnion('type', [
+  AccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  DataCapabilitySchema,
+]);
+
+export const GrantedCapabilitySchema = z.discriminatedUnion('type', [
+  GrantedAccountsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  GrantedDataCapabilitySchema,
+]);
+
+export const AppCapabilitiesSchema = z.object({
+  version: z.literal('1.0'),
+  metadata: z.object({
+    name: z.string(),
+    version: z.string(),
+    description: optional(z.string()),
+    url: optional(z.string()),
+    icon: optional(z.string()),
+  }),
+  capabilities: z.array(CapabilitySchema),
+  behavior: optional(
+    z.object({
+      mode: optional(z.enum(['strict', 'permissive'])),
+      expiration: optional(z.number()),
+    }),
+  ),
+});
+
+export const WalletCapabilitiesSchema = z.object({
+  version: z.literal('1.0'),
+  granted: z.array(GrantedCapabilitySchema),
+  wallet: z.object({
+    name: z.string(),
+    version: z.string(),
+  }),
+  expiresAt: optional(z.number()),
+});
+
+/**
+ * Record of all wallet method schemas (excluding batch).
+ * This is the single source of truth for method schemas - batch schemas are derived from this.
+ */
+const WalletMethodSchemas = {
+  getChainInfo: z
+    .function()
+    .args()
+    .returns(z.object({ chainId: schemas.Fr, version: schemas.Fr })),
+  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
+  getContractClassMetadata: z.function().args(schemas.Fr).returns(ContractClassMetadataSchema),
+  getPrivateEvents: z
+    .function()
+    .args(EventMetadataDefinitionSchema, PrivateEventFilterSchema)
+    .returns(z.array(PrivateEventSchema)),
+  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(z.union([TxHash.schema, TxReceipt.schema])),
+  createAuthWit: z.function().args(schemas.AztecAddress, MessageHashOrIntentSchema).returns(AuthWitness.schema),
+  requestCapabilities: z.function().args(AppCapabilitiesSchema).returns(WalletCapabilitiesSchema),
+};
+
+/**
+ * Creates batch schemas from the individual wallet methods.
+ * This allows us to define them once and derive batch schemas automatically,
+ * reducing duplication and ensuring consistency.
+ */
+function createBatchSchemas<T extends Record<string, z.ZodFunction<z.ZodTuple<any, any>, z.ZodTypeAny>>>(
+  methodSchemas: T,
+) {
+  const names = Object.keys(methodSchemas) as (keyof T)[];
+
+  const namesAndArgs = names.map(name =>
+    z.object({
+      name: z.literal(name),
+      args: methodSchemas[name].parameters(),
+    }),
+  );
+
+  const namesAndReturns = names.map(name =>
+    z.object({
+      name: z.literal(name),
+      result: methodSchemas[name].returnType(),
+    }),
+  );
+
+  // Type assertion needed because discriminatedUnion expects a tuple type [T, T, ...T[]]
+  // but we're building the array dynamically. The runtime behavior is correct.
+  return {
+    input: z.discriminatedUnion('name', namesAndArgs as [(typeof namesAndArgs)[0], ...typeof namesAndArgs]),
+    output: z.discriminatedUnion('name', namesAndReturns as [(typeof namesAndReturns)[0], ...typeof namesAndReturns]),
+  };
+}
+
+const { input: BatchedMethodSchema, output: BatchedResultSchema } = createBatchSchemas(WalletMethodSchemas);
+
+export { BatchedMethodSchema, BatchedResultSchema };
+
+export const WalletSchema: ApiSchemaFor<Wallet> = {
+  ...WalletMethodSchemas,
+  // @ts-expect-error - ApiSchemaFor cannot properly type generic methods with readonly arrays
+  batch: z.function().args(z.array(BatchedMethodSchema)).returns(z.array(BatchedResultSchema)),
+};

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/interface.d.ts

@@ -1,31 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CompleteAddress } from '@aztec/stdlib/contract';
-import type { EntrypointInterface } from '../entrypoint/entrypoint.js';
-/** Creates authorization witnesses. */
-export interface AuthWitnessProvider {
-    /**
-     * Computes an authentication witness from either a message hash
-     * @param messageHash - The message hash to approve
-     * @returns The authentication witness
-     */
-    createAuthWit(messageHash: Fr | Buffer): Promise<AuthWitness>;
-}
-/**
- * Handler for interfacing with an account. Knows how to create transaction execution
- * requests and authorize actions for its corresponding account.
- */
-export interface AccountInterface extends EntrypointInterface, AuthWitnessProvider {
-    /** Returns the complete address for this account. */
-    getCompleteAddress(): CompleteAddress;
-    /** Returns the address for this account. */
-    getAddress(): AztecAddress;
-    /** Returns the chain id for this account */
-    getChainId(): Fr;
-    /** Returns the rollup version for this account */
-    getVersion(): Fr;
-}
-//# sourceMappingURL=interface.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/account/interface.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,uCAAuC;AACvC,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,CAAC,WAAW,EAAE,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB,EAAE,mBAAmB;IAChF,qDAAqD;IACrD,kBAAkB,IAAI,eAAe,CAAC;IAEtC,4CAA4C;IAC5C,UAAU,IAAI,YAAY,CAAC;IAE3B,4CAA4C;IAC5C,UAAU,IAAI,EAAE,CAAC;IAEjB,kDAAkD;IAClD,UAAU,IAAI,EAAE,CAAC;CAClB"}

package/dest/account/interface.js

@@ -1,4 +0,0 @@
-/**
- * Handler for interfacing with an account. Knows how to create transaction execution
- * requests and authorize actions for its corresponding account.
- */ export { }; // docs:end:account-interface

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"}