@aztec/aztec.js 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/src/account/account.ts

@@ -1,97 +1,72 @@
 import type { DefaultAccountEntrypointOptions } from '@aztec/entrypoints/account';
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
-import { Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider, ChainInfo, EntrypointInterface } from '@aztec/entrypoints/interfaces';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { GasSettings } from '@aztec/stdlib/gas';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import { type CallIntent, type IntentInnerHash, computeAuthWitMessageHash } from '../utils/authwit.js';
-import type { AccountInterface } from './interface.js';
 
 /**
- * An authwit provider that can create both private and public authwits
- * with an intent as input, as opposed to just a precomputed inner hash
+ * Provides authorization for actions via the AuthWitness mechanism.
  */
-interface AuthwitnessIntentProvider {
+export interface AuthorizationProvider {
   /**
-   * Creates a private authwit from an intent or inner hash, to be provided
-   * during function execution
+   * Creates an authentication witness from an inner hash with consumer, or a call intent
    * @param intent - The action (or inner hash) to authorize
+   * @param chainInfo - Chain information needed for message hash computation
    */
-  createAuthWit(intent: IntentInnerHash | CallIntent | Buffer | Fr): Promise<AuthWitness>;
+  createAuthWit(intent: IntentInnerHash | CallIntent, chainInfo: ChainInfo): Promise<AuthWitness>;
 }
 
+// docs:start:account-interface
 /**
- * A type defining an account, capable of both creating authwits and using them
- * to authenticate transaction execution requests.
+ * Minimal interface for transaction execution and authorization.
  */
-export type Account = AccountInterface & AuthwitnessIntentProvider;
+export type Account = EntrypointInterface &
+  AuthorizationProvider & {
+    /** Returns the complete address for this account. */
+    getCompleteAddress(): CompleteAddress;
+    /** Returns the address for this account. */
+    getAddress(): AztecAddress;
+  };
+// docs:end:account-interface
 
 /**
  * An account implementation that uses authwits as an authentication mechanism
  * and can assemble transaction execution requests for an entrypoint.
  */
 export class BaseAccount implements Account {
-  constructor(protected account: AccountInterface) {}
+  constructor(
+    private entrypoint: EntrypointInterface,
+    private authWitnessProvider: AuthWitnessProvider,
+    private completeAddress: CompleteAddress,
+  ) {}
 
   createTxExecutionRequest(
     exec: ExecutionPayload,
     gasSettings: GasSettings,
+    chainInfo: ChainInfo,
     options: DefaultAccountEntrypointOptions,
   ): Promise<TxExecutionRequest> {
-    return this.account.createTxExecutionRequest(exec, gasSettings, options);
+    return this.entrypoint.createTxExecutionRequest(exec, gasSettings, chainInfo, options);
   }
 
-  getChainId(): Fr {
-    return this.account.getChainId();
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.entrypoint.wrapExecutionPayload(exec, options);
   }
 
-  getVersion(): Fr {
-    return this.account.getVersion();
+  async createAuthWit(messageHashOrIntent: CallIntent | IntentInnerHash, chainInfo: ChainInfo): Promise<AuthWitness> {
+    const messageHash = await computeAuthWitMessageHash(messageHashOrIntent, chainInfo);
+    return this.authWitnessProvider.createAuthWit(messageHash);
   }
 
-  /** Returns the complete address of the account that implements this wallet. */
-  public getCompleteAddress() {
-    return this.account.getCompleteAddress();
+  getCompleteAddress(): CompleteAddress {
+    return this.completeAddress;
   }
 
-  /** Returns the address of the account that implements this wallet. */
-  public getAddress() {
-    return this.getCompleteAddress().address;
-  }
-
-  /**
-   * Computes an authentication witness from either a message hash or an intent.
-   *
-   * If a message hash is provided, it will create a witness for the hash directly.
-   * Otherwise, it will compute the message hash using the intent, along with the
-   * chain id and the version values provided by the wallet.
-   *
-   * @param messageHashOrIntent - The message hash of the intent to approve
-   * @returns The authentication witness
-   */
-  async createAuthWit(messageHashOrIntent: Fr | Buffer | CallIntent | IntentInnerHash): Promise<AuthWitness> {
-    let messageHash: Fr;
-    if (Buffer.isBuffer(messageHashOrIntent)) {
-      messageHash = Fr.fromBuffer(messageHashOrIntent);
-    } else if (messageHashOrIntent instanceof Fr) {
-      messageHash = messageHashOrIntent;
-    } else {
-      messageHash = await this.getMessageHash(messageHashOrIntent);
-    }
-
-    return this.account.createAuthWit(messageHash);
-  }
-
-  /**
-   * Returns the message hash for the given intent
-   *
-   * @param intent - A tuple of (consumer and inner hash) or (caller and action)
-   * @returns The message hash
-   */
-  private getMessageHash(intent: IntentInnerHash | CallIntent): Promise<Fr> {
-    const chainId = this.getChainId();
-    const version = this.getVersion();
-    return computeAuthWitMessageHash(intent, { chainId, version });
+  getAddress(): AztecAddress {
+    return this.completeAddress.address;
   }
 }

package/src/account/account_contract.ts

@@ -1,11 +1,11 @@
-import type { AuthWitnessProvider, ChainInfo } from '@aztec/entrypoints/interfaces';
-import { Fr } from '@aztec/foundation/fields';
+import type { AuthWitnessProvider } from '@aztec/entrypoints/interfaces';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 import { getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { deriveKeys } from '@aztec/stdlib/keys';
 
-import type { AccountInterface } from './interface.js';
+import type { Account } from './account.js';
 
 /**
  * An account contract instance. Knows its artifact, deployment arguments, how to create
@@ -31,14 +31,13 @@ export interface AccountContract {
   >;
 
   /**
-   * Returns the account interface for this account contract given an instance at the provided address.
-   * The account interface is responsible for assembling tx requests given requested function calls, and
+   * 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.
-   * @param chainInfo - Chain id and version of the rollup where the account contract is initialized / published.
-   * @returns An account interface instance for creating tx requests and authorizing actions.
+   * @returns An account instance for creating tx requests and authorizing actions.
    */
-  getInterface(address: CompleteAddress, chainInfo: ChainInfo): AccountInterface;
+  getAccount(address: CompleteAddress): Account;
 
   /**
    * Returns the auth witness provider for the given address.

package/src/account/account_with_secret_key.ts

@@ -1,23 +1,48 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { ChainInfo } from '@aztec/entrypoints/interfaces';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+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 { GasSettings } from '@aztec/stdlib/gas';
 import { computeAddressSecret, deriveMasterIncomingViewingSecretKey } from '@aztec/stdlib/keys';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
 
-import { BaseAccount } from './account.js';
-import type { Salt } from './index.js';
-import type { AccountInterface } from './interface.js';
+import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
+import type { Account, Salt } from './index.js';
 
 /**
- * Extends {@link Account} with the encryption private key. Not required for
+ * Extends {@link BaseAccount} with the encryption private key. Not required for
  * implementing the wallet interface but useful for testing purposes or exporting
  * an account to another pxe.
  */
-export class AccountWithSecretKey extends BaseAccount {
+export class AccountWithSecretKey implements Account {
   constructor(
-    account: AccountInterface,
+    private account: Account,
     private secretKey: Fr,
     /** Deployment salt for this account contract. */
     public readonly salt: Salt,
-  ) {
-    super(account);
+  ) {}
+
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+    options?: any,
+  ): Promise<TxExecutionRequest> {
+    return this.account.createTxExecutionRequest(exec, gasSettings, chainInfo, options);
+  }
+
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.account.wrapExecutionPayload(exec, options);
+  }
+  createAuthWit(intent: IntentInnerHash | CallIntent, chainInfo: ChainInfo): Promise<AuthWitness> {
+    return this.account.createAuthWit(intent, chainInfo);
+  }
+  getCompleteAddress(): CompleteAddress {
+    return this.account.getCompleteAddress();
+  }
+  getAddress(): AztecAddress {
+    return this.account.getAddress();
   }
 
   /** Returns the encryption private key associated with this account. */

package/src/account/index.ts

@@ -3,10 +3,11 @@
  *
  * @packageDocumentation
  */
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 export { type AccountContract, getAccountContractAddress } from './account_contract.js';
-export { type AccountInterface } from './interface.js';
+export { type Account, BaseAccount, type AuthorizationProvider } from './account.js';
+export { AccountWithSecretKey } from './account_with_secret_key.js';
 
 /** A contract deployment salt. */
 export type Salt = Fr | number | bigint;

package/src/account/signerless_account.ts

@@ -1,12 +1,11 @@
 import type { ChainInfo, EntrypointInterface } from '@aztec/entrypoints/interfaces';
 import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall';
-import type { ExecutionPayload } from '@aztec/entrypoints/payload';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { GasSettings } from '@aztec/stdlib/gas';
-import type { TxExecutionRequest } from '@aztec/stdlib/tx';
+import type { ExecutionPayload, TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import type { CallIntent, IntentInnerHash } from '../utils/authwit.js';
 import type { Account } from './account.js';
@@ -16,20 +15,25 @@ import type { Account } from './account.js';
  */
 export class SignerlessAccount implements Account {
   private entrypoint: EntrypointInterface;
-  constructor(chainInfo: ChainInfo) {
-    this.entrypoint = new DefaultMultiCallEntrypoint(chainInfo.chainId.toNumber(), chainInfo.version.toNumber());
+
+  constructor() {
+    this.entrypoint = new DefaultMultiCallEntrypoint();
   }
 
-  createTxExecutionRequest(exec: ExecutionPayload, gasSettings: GasSettings): Promise<TxExecutionRequest> {
-    return this.entrypoint.createTxExecutionRequest(exec, gasSettings);
+  createTxExecutionRequest(
+    exec: ExecutionPayload,
+    gasSettings: GasSettings,
+    chainInfo: ChainInfo,
+  ): Promise<TxExecutionRequest> {
+    return this.entrypoint.createTxExecutionRequest(exec, gasSettings, chainInfo);
   }
 
-  getChainId(): Fr {
-    throw new Error('SignerlessAccount: Method getChainId not implemented.');
+  wrapExecutionPayload(exec: ExecutionPayload, options?: any): Promise<ExecutionPayload> {
+    return this.entrypoint.wrapExecutionPayload(exec, options);
   }
 
-  getVersion(): Fr {
-    throw new Error('SignerlessAccount: Method getVersion not implemented.');
+  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
+    throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
   }
 
   getCompleteAddress(): CompleteAddress {
@@ -39,8 +43,4 @@ export class SignerlessAccount implements Account {
   getAddress(): AztecAddress {
     throw new Error('SignerlessAccount: Method getAddress not implemented.');
   }
-
-  createAuthWit(_intent: Fr | Buffer | IntentInnerHash | CallIntent): Promise<AuthWitness> {
-    throw new Error('SignerlessAccount: Method createAuthWit not implemented.');
-  }
 }

package/src/api/account.ts

@@ -1,6 +1,13 @@
-export { type AccountContract, type AccountInterface, type Salt, getAccountContractAddress } from '../account/index.js';
+export {
+  type Account,
+  type AccountContract,
+  AccountWithSecretKey,
+  BaseAccount,
+  type AuthorizationProvider,
+  getAccountContractAddress,
+  type Salt,
+} from '../account/index.js';
 export type { AuthWitnessProvider, ChainInfo } from '@aztec/entrypoints/interfaces';
+export { ChainInfoSchema } from '@aztec/entrypoints/interfaces';
 
-export { AccountWithSecretKey } from '../account/account_with_secret_key.js';
-export { type Account, BaseAccount } from '../account/account.js';
 export { SignerlessAccount } from '../account/signerless_account.js';

package/src/api/authorization.ts

@@ -2,6 +2,7 @@ export { AuthWitness } from '@aztec/stdlib/auth-witness';
 export {
   SetPublicAuthwitContractInteraction,
   type ContractFunctionInteractionCallIntent,
+  isContractFunctionInteractionCallIntent,
   getMessageHashFromIntent,
   computeAuthWitMessageHash,
   computeInnerAuthWitHashFromAction,

package/src/api/contract.ts

@@ -1,7 +1,7 @@
 /**
  * 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/how_to_compile_contract | Compiling contracts}
+ * `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
@@ -10,13 +10,21 @@
  * or can be queried via `simulate()`.
  *
  * ```ts
- * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send().deployed();
+ * // Deploy and get the contract instance directly (default behavior)
+ * const contract = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({ from: accountAddress });
  * console.log(`Contract deployed at ${contract.address}`);
+ *
+ * // Or get the full receipt with contract and instance
+ * const receipt = await Contract.deploy(wallet, MyContractArtifact, [...constructorArgs]).send({
+ *   from: accountAddress,
+ *   wait: { returnReceipt: true }
+ * });
+ * console.log(`Contract deployed at ${receipt.contract.address}`);
  * ```
  *
  * ```ts
- * const contract = await Contract.at(address, MyContractArtifact, wallet);
- * await contract.methods.mint(1000, owner).send().wait();
+ * 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()}`);
  * ```
  *
@@ -25,12 +33,11 @@
  * 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 result of `send`ing a transaction is a {@link SentTx} object, from which you can get the
- * transaction hash, or simply `wait` until the transaction is mined and the local PXE
- * has synchronized its changes.
+ * 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/how_to_compile_contract#use-generated-interfaces | autogenerated type-safe interfaces}
+ * {@link https://docs.aztec.network/developers/aztec-nr/compiling_contracts#use-generated-interfaces | autogenerated type-safe interfaces}
  * for interacting with your contracts.
  *
  * @packageDocumentation
@@ -39,26 +46,35 @@ export { Contract } from '../contract/contract.js';
 export { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
 
 export {
+  NO_WAIT,
+  type NoWait,
   type RequestInteractionOptions,
   type SendInteractionOptions,
   type ProfileInteractionOptions,
   type SimulateInteractionOptions,
   type InteractionFeeOptions,
+  type InteractionWaitOptions,
+  type GasSettingsOption,
+  type SendReturn,
+  type SimulationReturn,
   toProfileOptions,
   toSendOptions,
   toSimulateOptions,
 } from '../contract/interaction_options.js';
 
-export { DefaultWaitOpts, SentTx, type WaitOpts } from '../contract/sent_tx.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 DeployOptions,
+  type DeployReturn,
+  type DeployTxReceipt,
+  type DeployWaitOptions,
+  type DeployInteractionWaitOptions,
   DeployMethod,
   type RequestDeployOptions,
   type SimulateDeployOptions,
 } from '../contract/deploy_method.js';
-export { DeploySentTx } from '../contract/deploy_sent_tx.js';
 export { waitForProven, type WaitForProvenOpts, DefaultWaitForProvenOpts } from '../contract/wait_for_proven.js';
 export { getGasLimits } from '../contract/get_gas_limits.js';
 

package/src/api/deployment.ts

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

package/src/api/events.ts

@@ -1,44 +1,52 @@
 import { type EventMetadataDefinition, EventSelector, decodeFromAbi } from '@aztec/stdlib/abi';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
+import type { PublicEvent, PublicEventFilter } from '../wallet/wallet.js';
+
 /**
  * Returns decoded public events given search parameters.
  * @param node - The node to request events from
- * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
- * @param from - The block number to search from.
- * @param limit - The amount of blocks to search.
- * @returns - The deserialized events.
+ * @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.
+ *   - `txHash`: Transaction in which the events were emitted.
+ *   - `fromBlock`: The block number from which to start fetching events (inclusive). Defaults to 1.
+ *   - `toBlock`: The block number until which to fetch events (not inclusive). Defaults to latest + 1.
+ * @returns - The decoded events with metadata.
  */
-export async function getDecodedPublicEvents<T>(
+export async function getPublicEvents<T>(
   node: AztecNode,
   eventMetadataDef: EventMetadataDefinition,
-  from: number,
-  limit: number,
-): Promise<T[]> {
+  filter: PublicEventFilter,
+): Promise<PublicEvent<T>[]> {
   const { logs } = await node.getPublicLogs({
-    fromBlock: from,
-    toBlock: from + limit,
+    fromBlock: filter.fromBlock ? Number(filter.fromBlock) : undefined,
+    toBlock: filter.toBlock ? Number(filter.toBlock) : undefined,
+    txHash: filter.txHash,
+    contractAddress: filter.contractAddress,
   });
 
-  const decodedEvents = logs
-    .map(log => {
-      // +1 for the event selector
-      const expectedLength = eventMetadataDef.fieldNames.length + 1;
-      if (log.log.fields.length !== expectedLength) {
-        throw new Error(
-          `Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length. Expected ${expectedLength}. Got ${log.log.fields.length}.`,
-        );
-      }
+  const decodedEvents: PublicEvent<T>[] = [];
+
+  for (const log of logs) {
+    const logFields = log.log.getEmittedFields();
+    // Event selector is at the last position of the emitted fields
+    const logEventSelector = EventSelector.fromField(logFields[logFields.length - 1]);
 
-      const logFields = log.log.getEmittedFields();
-      // We are assuming here that event logs are the last 4 bytes of the event. This is not enshrined but is a function of aztec.nr raw log emission.
-      if (!EventSelector.fromField(logFields[logFields.length - 1]).equals(eventMetadataDef.eventSelector)) {
-        return undefined;
-      }
+    if (!logEventSelector.equals(eventMetadataDef.eventSelector)) {
+      continue;
+    }
 
-      return decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T;
-    })
-    .filter(log => log !== undefined) as T[];
+    decodedEvents.push({
+      event: decodeFromAbi([eventMetadataDef.abiType], log.log.fields) as T,
+      metadata: {
+        l2BlockNumber: log.id.blockNumber,
+        l2BlockHash: log.id.blockHash,
+        txHash: log.id.txHash,
+        contractAddress: log.log.contractAddress,
+      },
+    });
+  }
 
   return decodedEvents;
 }

package/src/api/fields.ts

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

package/src/api/keys.ts

@@ -1,8 +1,8 @@
 export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
 export {
-  computeAppNullifierSecretKey,
+  computeAppNullifierHidingKey,
   deriveKeys,
   deriveMasterIncomingViewingSecretKey,
-  deriveMasterNullifierSecretKey,
+  deriveMasterNullifierHidingKey,
 } from '@aztec/stdlib/keys';
 export { generatePublicKey } from '../utils/pub_key.js';

package/src/api/node.ts

@@ -3,18 +3,22 @@
  *
  * 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.
+ * the node to be ready before proceeding, and {@link waitForTx} to wait for a transaction
+ * to be mined.
  *
  * @example
  * ```ts
- * import { createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+ * import { createAztecNodeClient, waitForNode, waitForTx } from '@aztec/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, type AztecNode } from '../utils/node.js';
+export { createAztecNodeClient, waitForNode, waitForTx, type AztecNode } from '../utils/node.js';
 export { type NodeInfo } from '@aztec/stdlib/contract';

package/src/api/note.ts

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

package/src/api/protocol.ts

@@ -1,2 +1,9 @@
 export { ProtocolContractAddress } from '@aztec/protocol-contracts';
 export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+
+export { AuthRegistryContract } from '../contract/protocol_contracts/auth-registry.js';
+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';
+export { MultiCallEntrypointContract } from '../contract/protocol_contracts/multi-call-entrypoint.js';
+export { PublicChecksContract } from '../contract/protocol_contracts/public-checks.js';

package/src/api/tx.ts

@@ -1,11 +1,15 @@
 export {
   Tx,
   TxExecutionRequest,
+  TxExecutionResult,
   TxHash,
   TxReceipt,
   TxStatus,
+  SortedTxStatuses,
   Capsule,
   HashedValues,
   GlobalVariables,
   TxProfileResult,
+  ExecutionPayload,
+  mergeExecutionPayloads,
 } from '@aztec/stdlib/tx';