@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/src/account/account_contract.ts

@@ -0,0 +1,80 @@
+import type { AuthWitnessProvider } from '@aztec-labs/entrypoints/interfaces';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { ContractArtifact } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { CompleteAddress } from '@aztec-labs/stdlib/contract';
+import { getContractInstanceFromInstantiationParams } from '@aztec-labs/stdlib/contract';
+import { deriveKeys } from '@aztec-labs/stdlib/keys';
+
+import type { Account } from './account.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 initializer function name and arguments for this instance, or undefined if this contract does not require initialization.
+   */
+  getInitializationFunctionAndArgs(): Promise<
+    | {
+        /** The name of the function used to initialize the contract */
+        constructorName: string;
+        /** The args to the function used to initialize the contract */
+        constructorArgs: any[];
+      }
+    | undefined
+  >;
+
+  /**
+   * The hash of this account's immutable instantiation params, committed into its address. Returns
+   * undefined for accounts that have no immutables (these are instead deployed via an onchain
+   * initializer, which contributes to the address through its initialization hash).
+   */
+  getImmutablesHash(): Promise<Fr | undefined>;
+
+  /**
+   * Returns the account implementation for this account contract given an instance at the provided address.
+   * The account is responsible for assembling tx requests given requested function calls, and
+   * for creating signed auth witnesses given action identifiers (message hashes).
+   * @param address - Address of this account contract.
+   * @returns An account instance for creating tx requests and authorizing actions.
+   */
+  getAccount(address: CompleteAddress): Account;
+
+  /**
+   * 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, salt and optional immutables hash
+ */
+export async function getAccountContractAddress(
+  accountContract: AccountContract,
+  secret: Fr,
+  salt: Fr,
+  immutablesHash?: Fr,
+): Promise<AztecAddress> {
+  const { publicKeys } = await deriveKeys(secret);
+  const { constructorName, constructorArgs } = (await accountContract.getInitializationFunctionAndArgs()) ?? {
+    constructorName: undefined,
+    constructorArgs: undefined,
+  };
+  const artifact = await accountContract.getContractArtifact();
+  const instance = await getContractInstanceFromInstantiationParams(artifact, {
+    constructorArtifact: constructorName,
+    constructorArgs,
+    salt,
+    publicKeys,
+    immutablesHash: immutablesHash ?? (await accountContract.getImmutablesHash()),
+  });
+  return instance.address;
+}

package/src/account/index.ts

@@ -0,0 +1,12 @@
+/**
+ * The `account` module provides utilities for managing accounts.
+ *
+ * @packageDocumentation
+ */
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+export { type AccountContract, getAccountContractAddress } from './account_contract.js';
+export { type Account, BaseAccount, type AuthorizationProvider } from './account.js';
+
+/** A contract deployment salt. */
+export type Salt = Fr | number | bigint;

package/src/api/README.md

@@ -0,0 +1,7 @@
+# API
+
+This provides a more modular api for importing parts of the library as needed.
+The root `index.js` just exposes everything, which can have consequences for startup times and optimizations.
+Here we can gradually build up a much more granular api to allow importing precisely what's needed.
+This should adopt the opposite philosophy to "export all my child exports".
+Every file should (usually) export one thing, and the file/directory structure should be reflected in package.json exports.

package/src/api/abi.ts

@@ -0,0 +1,42 @@
+export {
+  type ContractArtifact,
+  type FunctionArtifact,
+  type FunctionAbi,
+  EventSelector,
+  FunctionType,
+  FunctionSelector,
+  FunctionCall,
+  NoteSelector,
+  type ABIParameter,
+  decodeFromAbi,
+  decodeEachFromAbi,
+  encodeArguments,
+  getFunctionReturnType,
+  type AbiType,
+  type AbiValue,
+  type AbiNamedValue,
+  getGlobalsByTag,
+  isAddressStruct,
+  isAztecAddressStruct,
+  isEthAddressStruct,
+  isWrappedFieldStruct,
+  isFunctionSelectorStruct,
+  loadContractArtifact,
+  loadContractArtifactForPublic,
+  getAllFunctionAbis,
+  contractArtifactToBuffer,
+  contractArtifactFromBuffer,
+} from '@aztec-labs/stdlib/abi';
+export { type NoirCompiledContract } from '@aztec-labs/stdlib/noir';
+
+// Type converters for flexible parameter types in contract calls
+export {
+  type AztecAddressLike,
+  type EthAddressLike,
+  type EventSelectorLike,
+  type FieldLike,
+  type FunctionSelectorLike,
+  type OptionLike,
+  type U128Like,
+  type WrappedFieldLike,
+} from '../utils/abi_types.js';

package/src/api/account.ts

@@ -0,0 +1,12 @@
+export {
+  type Account,
+  type AccountContract,
+  BaseAccount,
+  type AuthorizationProvider,
+  getAccountContractAddress,
+  type Salt,
+} from '../account/index.js';
+export type { AuthWitnessProvider, ChainInfo } from '@aztec-labs/entrypoints/interfaces';
+export { ChainInfoSchema } from '@aztec-labs/entrypoints/interfaces';
+
+export { NO_FROM, type NoFrom } from '../contract/interaction_options.js';

package/src/api/addresses.ts

@@ -0,0 +1,3 @@
+export { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+export { CompleteAddress } from '@aztec-labs/stdlib/contract';
+export { EthAddress } from '@aztec-labs/foundation/eth-address';

package/src/api/authorization.ts

@@ -0,0 +1,15 @@
+export { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+export {
+  SetPublicAuthwitContractInteraction,
+  type ContractFunctionInteractionCallIntent,
+  isContractFunctionInteractionCallIntent,
+  getMessageHashFromIntent,
+  computeAuthWitMessageHash,
+  computeInnerAuthWitHashFromAction,
+  lookupValidity,
+  type CallIntent,
+  type IntentInnerHash,
+} from '../utils/authwit.js';
+export { computeInnerAuthWitHash } from '@aztec-labs/stdlib/auth-witness';
+
+export { CallAuthorizationRequest } from '../authorization/call_authorization_request.js';

package/src/api/block.ts

@@ -0,0 +1,2 @@
+export { Body, L2Block } from '@aztec-labs/stdlib/block';
+export { getTimestampRangeForEpoch } from '@aztec-labs/stdlib/epoch-helpers';

package/src/api/contract.ts

@@ -0,0 +1,86 @@
+/**
+ * The `contract` module provides utilities for deploying and interacting with contracts, based on a
+ * `Wallet` instance and a compiled artifact. Refer to the {@link account} module for how to obtain a valid
+ * `Wallet` instance, and to the {@link https://docs.aztec.network/developers/aztec-nr/compiling_contracts | Compiling contracts}
+ * section of the documentation for how to generate an artifact out of your Noir source code.
+ *
+ * The {@link Contract} class is the main class in this module, and provides static methods for deploying
+ * a contract or interacting with an already deployed one. The `methods` property of the contract instance
+ * provides access to private, public, and simulate methods, that can be invoked in a transaction via `send()`,
+ * or can be queried via `simulate()`.
+ *
+ * ```ts
+ * // Deploy and get the contract, receipt, and instance
+ * const { contract, receipt, instance } = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({ from: accountAddress });
+ * console.log(`Contract deployed at ${contract.address}`);
+ * ```
+ *
+ * ```ts
+ * const contract = Contract.at(address, MyContractArtifact, wallet);
+ * await contract.methods.mint(1000, owner).send({ from: accountAddress });
+ * console.log(`Total supply is now ${await contract.methods.totalSupply().simulate()}`);
+ * ```
+ *
+ * The result of calling a method in a contract instance, such as `contract.methods.mint(1000, owner)`
+ * in the example, is a {@link ContractFunctionInteraction} instance. Usually this will be just sent as
+ * a transaction to the network via the `send` method, but you can also `simulate` it without sending,
+ * or obtaining the `request` for aggregating into a {@link BatchCall}.
+ *
+ * The `send` method returns a {@link TxReceipt} by default (waits for the transaction to be mined).
+ * If you pass `wait: NO_WAIT` in the options, it will return a {@link TxHash} immediately without waiting.
+ *
+ * @remarks If you are using typescript, consider using the
+ * {@link https://docs.aztec.network/developers/aztec-nr/compiling_contracts#use-generated-interfaces | autogenerated type-safe interfaces}
+ * for interacting with your contracts.
+ *
+ * @packageDocumentation
+ */
+export { Contract } from '../contract/contract.js';
+export { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+
+export {
+  NO_WAIT,
+  type NoWait,
+  type OffchainMessage,
+  type OffchainOutput,
+  type RequestInteractionOptions,
+  type SendInteractionOptions,
+  type ProfileInteractionOptions,
+  type SimulateInteractionOptions,
+  type InteractionFeeOptions,
+  type InteractionWaitOptions,
+  type GasSettingsOption,
+  type SendReturn,
+  type SimulationResult,
+  type TxSendResultImmediate,
+  type TxSendResultMined,
+  extractOffchainOutput,
+  toProfileOptions,
+  toSendOptions,
+  toSimulateOptions,
+} from '../contract/interaction_options.js';
+
+export { DefaultWaitOpts, type WaitOpts } from '../contract/wait_opts.js';
+export { ContractBase, type ContractMethod, type ContractStorageLayout } from '../contract/contract_base.js';
+export { BatchCall } from '../contract/batch_call.js';
+export {
+  type DeployInstantiationOptions,
+  type DeployOptions,
+  type DeployResultMined,
+  type DeployReturn,
+  DeployMethod,
+  type RequestDeployOptions,
+  type SimulateDeployOptions,
+  UniversalDeployMethod,
+} from '../contract/deploy_method.js';
+export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
+export { fastForwardContractUpdate } from '../contract/fastforward_contract_update.js';
+
+export {
+  type PartialAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromInstantiationParams,
+  type NodeInfo,
+} from '@aztec-labs/stdlib/contract';

package/src/api/crypto.ts

@@ -0,0 +1 @@
+export { computeSecretHash } from '@aztec-labs/stdlib/hash';

package/src/api/deployment.ts

@@ -0,0 +1,3 @@
+export { publishContractClass } from '../deployment/publish_class.js';
+export { publishInstance } from '../deployment/publish_instance.js';
+export { ContractDeployer } from '../deployment/contract_deployer.js';

package/src/api/eth_address.ts

@@ -0,0 +1 @@
+export { EthAddress } from '@aztec-labs/foundation/eth-address';

package/src/api/ethereum.ts

@@ -0,0 +1,10 @@
+export {
+  L1FeeJuicePortalManager,
+  L1ToL2TokenPortalManager,
+  L1TokenManager,
+  L1TokenPortalManager,
+  type L2AmountClaim,
+  type L2AmountClaimWithRecipient,
+  type L2Claim,
+  generateClaimSecret,
+} from '../ethereum/portal_manager.js';

package/src/api/event_cursor.ts

@@ -0,0 +1,60 @@
+import { type BlockNumber, BlockNumberSchema } from '@aztec-labs/foundation/branded-types';
+import { LogCursor } from '@aztec-labs/stdlib/logs';
+import { schemas } from '@aztec-labs/stdlib/schemas';
+import { z } from 'zod';
+
+/**
+ * Opaque cursor marking a position in a contract's public event stream. Obtain one from
+ * {@link GetPublicEventsResult.nextCursor} and pass it back as {@link PublicEventFilter.afterEvent} to
+ * fetch the next page.
+ *
+ * This is the public-events counterpart of the node-layer {@link LogCursor}
+ **/
+export class EventCursor {
+  constructor(
+    /** The block the cursor points to. */
+    public readonly blockNumber: BlockNumber,
+    /** The tx index within the block the cursor points to. */
+    public readonly txIndexWithinBlock: number,
+    /** The log index within the tx the cursor points to. */
+    public readonly logIndexWithinTx: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        blockNumber: BlockNumberSchema,
+        txIndexWithinBlock: schemas.Integer,
+        logIndexWithinTx: schemas.Integer,
+      })
+      .transform(
+        ({ blockNumber, txIndexWithinBlock, logIndexWithinTx }) =>
+          new EventCursor(blockNumber, txIndexWithinBlock, logIndexWithinTx),
+      );
+  }
+
+  /**
+   * Bridges from the node-layer {@link LogCursor}. Explicit on purpose — see the class doc.
+   * @param cursor - The node-layer cursor to wrap.
+   */
+  static fromLogCursor(cursor: LogCursor): EventCursor {
+    return new EventCursor(cursor.blockNumber, cursor.txIndexWithinBlock, cursor.logIndexWithinTx);
+  }
+
+  /** Bridges to the node-layer {@link LogCursor}. Explicit on purpose — see the class doc. */
+  toLogCursor(): LogCursor {
+    return new LogCursor(this.blockNumber, this.txIndexWithinBlock, this.logIndexWithinTx);
+  }
+
+  equals(other: EventCursor): boolean {
+    return (
+      this.blockNumber === other.blockNumber &&
+      this.txIndexWithinBlock === other.txIndexWithinBlock &&
+      this.logIndexWithinTx === other.logIndexWithinTx
+    );
+  }
+
+  toString(): string {
+    return `${this.blockNumber}-${this.txIndexWithinBlock}-${this.logIndexWithinTx}`;
+  }
+}

package/src/api/events.ts

@@ -0,0 +1,79 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+import { type EventMetadataDefinition, decodeFromAbi } from '@aztec-labs/stdlib/abi';
+import { computeLogTag } from '@aztec-labs/stdlib/hash';
+import { MAX_LOGS_PER_TAG } from '@aztec-labs/stdlib/interfaces/api-limit';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+import { LogCursor, type PublicLogsQuery, Tag } from '@aztec-labs/stdlib/logs';
+
+import type { PublicEvent, PublicEventFilter } from '../wallet/wallet.js';
+import { EventCursor } from './event_cursor.js';
+
+export { EventCursor };
+
+/** Result of a single page of a public event query. */
+export type GetPublicEventsResult<T> = {
+  /** The decoded events with metadata. At most `MAX_LOGS_PER_TAG` (the node's per-tag page size). */
+  events: PublicEvent<T>[];
+  /**
+   * If present, use it to fetch the next page by setting `afterEvent` to it. Absent when all events in the range have
+   * been returned.
+   */
+  nextCursor?: EventCursor;
+};
+
+/**
+ * Returns a page of decoded public events given search parameters.
+ *
+ * A single call returns at most `MAX_LOGS_PER_TAG` events (the node's per-tag page size). When more events exist,
+ * `nextCursor` points past the last returned event. Pass it as `afterEvent` to fetch the next page. When `nextCursor`
+ * is absent, all events in the range have been returned.
+ *
+ * @param node - The node to request events from.
+ * @param eventMetadataDef - Metadata of the event. This should be the class generated from the contract.
+ *   e.g. `Contract.events.Event`.
+ * @param filter - Filter options for the event query:
+ *   - `contractAddress`: The address of the contract that emitted the events. Required.
+ *   - `txHash`: Transaction in which the events were emitted (mutually exclusive with `fromBlock`/`toBlock`).
+ *   - `fromBlock`: The block number from which to start fetching events (inclusive). Optional.
+ *   - `toBlock`: The block number until which to fetch events (not inclusive). Optional.
+ *   - `afterEvent`: Cursor to resume strictly after. Optional. When set, only events after this cursor
+ *     are returned.
+ * @returns A page of decoded events with metadata, plus a `nextCursor` to continue (absent when done).
+ */
+export async function getPublicEvents<T>(
+  node: AztecNode,
+  eventMetadataDef: EventMetadataDefinition,
+  filter: PublicEventFilter,
+): Promise<GetPublicEventsResult<T>> {
+  // Public events are tagged with a domain-separated hash of their event type ID, so we compute
+  // the same hash here to filter for logs of the requested event type.
+  const logTagField = await computeLogTag(eventMetadataDef.eventSelector.toField(), DomainSeparator.EVENT_LOG_TAG);
+  const logTag = new Tag(logTagField);
+
+  const afterLog = filter.afterEvent?.toLogCursor();
+  const query: PublicLogsQuery = {
+    contractAddress: filter.contractAddress,
+    tags: [afterLog !== undefined ? { tag: logTag, afterLog } : logTag],
+    fromBlock: filter.fromBlock,
+    toBlock: filter.toBlock,
+    txHash: filter.txHash,
+  };
+
+  const [logsForTag] = await node.getPublicLogsByTags(query);
+  const events: PublicEvent<T>[] = logsForTag.map(log => ({
+    event: decodeFromAbi(eventMetadataDef.abiType, log.logData.slice(1)) as T,
+    metadata: {
+      l2BlockNumber: log.blockNumber,
+      l2BlockHash: log.blockHash,
+      txHash: log.txHash,
+      contractAddress: filter.contractAddress,
+    },
+  }));
+
+  const nextCursor =
+    logsForTag.length === MAX_LOGS_PER_TAG
+      ? EventCursor.fromLogCursor(LogCursor.fromLog(logsForTag[logsForTag.length - 1]))
+      : undefined;
+
+  return { events, nextCursor };
+}

package/src/api/fee.ts

@@ -0,0 +1,5 @@
+export type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+export { PrivateFeePaymentMethod } from '../fee/private_fee_payment_method.js';
+export { PublicFeePaymentMethod } from '../fee/public_fee_payment_method.js';
+export { FeeJuicePaymentMethodWithClaim } from '../fee/fee_juice_payment_method_with_claim.js';
+export { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fee_testing.ts

@@ -0,0 +1 @@
+export { SponsoredFeePaymentMethod } from '../fee/sponsored_fee_payment.js';

package/src/api/fields.ts

@@ -0,0 +1,3 @@
+export { Fr, Fq } from '@aztec-labs/foundation/curves/bn254';
+export { GrumpkinScalar, Point } from '@aztec-labs/foundation/curves/grumpkin';
+export { BlockNumber } from '@aztec-labs/foundation/branded-types';

package/src/api/keys.ts

@@ -0,0 +1,8 @@
+export { type MasterSecretKeys, type PublicKey, PublicKeys } from '@aztec-labs/stdlib/keys';
+export {
+  computeAppNullifierHidingKey,
+  deriveKeys,
+  deriveMasterIncomingViewingSecretKey,
+  deriveMasterNullifierHidingSecretKey,
+} from '@aztec-labs/stdlib/keys';
+export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/log.ts

@@ -0,0 +1,2 @@
+export { createLogger, type Logger } from '@aztec-labs/foundation/log';
+export { LogCursor, type LogResult } from '@aztec-labs/stdlib/logs';

package/src/api/messaging.ts

@@ -0,0 +1,2 @@
+export { L1ToL2Message, L2Actor, L1Actor } from '@aztec-labs/stdlib/messaging';
+export { isL1ToL2MessageReady, waitForL1ToL2MessageReady } from '../utils/cross_chain.js';

package/src/api/node.ts

@@ -0,0 +1,30 @@
+/**
+ * The `node` module provides utilities for connecting to and interacting with an Aztec node.
+ *
+ * The primary function is {@link createAztecNodeClient}, which creates a JSON-RPC client
+ * that connects to a running Aztec node instance. Use {@link waitForNode} to wait for
+ * the node to be ready before proceeding, and {@link waitForTx} to wait for a transaction
+ * to be mined.
+ *
+ * @example
+ * ```ts
+ * import { createAztecNodeClient, waitForNode, waitForTx } from '@aztec-labs/aztec.js/node';
+ *
+ * const node = createAztecNodeClient('http://localhost:8080');
+ * await waitForNode(node);
+ * const blockNumber = await node.getBlockNumber();
+ *
+ * // Wait for a transaction
+ * const receipt = await waitForTx(node, txHash);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export {
+  createAztecNodeClient,
+  waitForNode,
+  waitForTx,
+  type AztecNode,
+  type AztecNodeClientOptions,
+} from '../utils/node.js';
+export { type NodeInfo } from '@aztec-labs/stdlib/contract';

package/src/api/note.ts

@@ -0,0 +1 @@
+export { Comparator, Note } from '@aztec-labs/stdlib/note';

package/src/api/protocol.ts

@@ -0,0 +1,6 @@
+export { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+export { INITIAL_L2_BLOCK_NUM } from '@aztec-labs/constants';
+
+export { ContractClassRegistryContract } from '../contract/protocol_contracts/contract-class-registry.js';
+export { ContractInstanceRegistryContract } from '../contract/protocol_contracts/contract-instance-registry.js';
+export { FeeJuiceContract } from '../contract/protocol_contracts/fee-juice.js';

package/src/api/trees.ts

@@ -0,0 +1,2 @@
+export { SiblingPath } from '@aztec-labs/foundation/trees';
+export { MerkleTreeId, merkleTreeIds } from '@aztec-labs/stdlib/trees';

package/src/api/tx.ts

@@ -0,0 +1,20 @@
+export {
+  Tx,
+  TxExecutionRequest,
+  TxExecutionResult,
+  TxHash,
+  TxStatus,
+  SortedTxStatuses,
+  PendingTxReceipt,
+  DroppedTxReceipt,
+  MinedTxReceipt,
+  TxReceiptSchema,
+  GetTxReceiptOptionsSchema,
+  Capsule,
+  HashedValues,
+  GlobalVariables,
+  TxProfileResult,
+  ExecutionPayload,
+  mergeExecutionPayloads,
+} from '@aztec-labs/stdlib/tx';
+export type { TxReceipt, GetTxReceiptOptions } from '@aztec-labs/stdlib/tx';

package/src/api/utils.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility functions for aztec.js.
+ *
+ * NOTE: This module contains low-usage utilities and may be deprecated in the future.
+ * Prefer using more specific modules:
+ * - Node connection utilities → `@aztec-labs/aztec.js/node`
+ * - Type converters → `@aztec-labs/aztec.js/abi`
+ * - Key generation → `@aztec-labs/aztec.js/keys`
+ * - Messaging utilities → `@aztec-labs/aztec.js/messaging`
+ */
+
+// Low-usage utilities - consider these internal/experimental
+export { getFeeJuiceBalance } from '../utils/fee_juice.js';
+export { readFieldCompressedString } from '../utils/field_compressed_string.js';

package/src/api/wallet.ts

@@ -0,0 +1,83 @@
+export {
+  type Aliased,
+  type SimulateOptions,
+  type ExecuteUtilityOptions,
+  type ProfileOptions,
+  type SendOptions,
+  type BatchableMethods,
+  type BatchedMethod,
+  type BatchedMethodResult,
+  type BatchedMethodResultWrapper,
+  type BatchResults,
+  type Wallet,
+  type PrivateEvent,
+  type PrivateEventFilter,
+  type PublicEvent,
+  type PublicEventFilter,
+  type ContractMetadata,
+  ContractInitializationStatus,
+  type ContractClassMetadata,
+  AppCapabilitiesSchema,
+  WalletCapabilitiesSchema,
+  ExecutionPayloadSchema,
+  GasSettingsOptionSchema,
+  WaitOptsSchema,
+  SendOptionsSchema,
+  SimulateOptionsSchema,
+  ProfileOptionsSchema,
+  MessageHashOrIntentSchema,
+  BatchedMethodSchema,
+  EventMetadataDefinitionSchema,
+  PrivateEventSchema,
+  PrivateEventFilterSchema,
+  PublicEventSchema,
+  PublicEventFilterSchema,
+  ContractClassMetadataSchema,
+  ContractMetadataSchema,
+  WalletSchema,
+  ContractFunctionPatternSchema,
+  AccountsCapabilitySchema,
+  GrantedAccountsCapabilitySchema,
+  ContractsCapabilitySchema,
+  GrantedContractsCapabilitySchema,
+  ContractClassesCapabilitySchema,
+  GrantedContractClassesCapabilitySchema,
+  SimulationCapabilitySchema,
+  GrantedSimulationCapabilitySchema,
+  TransactionCapabilitySchema,
+  GrantedTransactionCapabilitySchema,
+  DataCapabilitySchema,
+  GrantedDataCapabilitySchema,
+  CapabilitySchema,
+  GrantedCapabilitySchema,
+} from '../wallet/wallet.js';
+
+export {
+  type AppCapabilities,
+  type WalletCapabilities,
+  CAPABILITY_VERSION,
+  type Capability,
+  type GrantedCapability,
+  type ContractFunctionPattern,
+  type AccountsCapability,
+  type GrantedAccountsCapability,
+  type ContractsCapability,
+  type GrantedContractsCapability,
+  type ContractClassesCapability,
+  type GrantedContractClassesCapability,
+  type SimulationCapability,
+  type GrantedSimulationCapability,
+  type TransactionCapability,
+  type GrantedTransactionCapability,
+  type DataCapability,
+  type GrantedDataCapability,
+} from '../wallet/capabilities.js';
+
+export { AccountManager } from '../wallet/account_manager.js';
+
+export { TxSimulationResultWithAppOffset } from '../wallet/tx_simulation_result_with_app_offset.js';
+
+export { type PublicStorageOverride, PublicStorageOverrideSchema } from '@aztec-labs/stdlib/interfaces/client';
+export { SimulationOverrides } from '@aztec-labs/stdlib/tx';
+
+export { type DeployAccountOptions, DeployAccountMethod } from '../wallet/deploy_account_method.js';