@aztec/aztec.js 0.0.0-test.0

package/src/entrypoint/payload.ts

@@ -0,0 +1,238 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { FunctionCall, FunctionType } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { HashedValues } from '@aztec/stdlib/tx';
+
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+
+/**
+ * Fee payment options for a transaction.
+ */
+export type FeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings: GasSettings;
+};
+
+// docs:start:user_fee_options
+/** Fee options as set by a user. */
+export type UserFeeOptions = {
+  /** The fee payment method to use */
+  paymentMethod?: FeePaymentMethod;
+  /** The gas settings */
+  gasSettings?: Partial<FieldsOf<GasSettings>>;
+  /** Percentage to pad the base fee by, if empty, defaults to 0.5 */
+  baseFeePadding?: number;
+  /** Whether to run an initial simulation of the tx with high gas limit to figure out actual gas settings. */
+  estimateGas?: boolean;
+  /** Percentage to pad the estimated gas limits by, if empty, defaults to 0.1. Only relevant if estimateGas is set. */
+  estimatedGasPadding?: number;
+};
+// docs:end:user_fee_options
+
+// These must match the values defined in:
+// - noir-projects/aztec-nr/aztec/src/entrypoint/app.nr
+const APP_MAX_CALLS = 4;
+// - and noir-projects/aztec-nr/aztec/src/entrypoint/fee.nr
+const FEE_MAX_CALLS = 2;
+
+/* eslint-disable camelcase */
+/** Encoded function call for account contract entrypoint */
+type EncodedFunctionCall = {
+  /** Arguments hash for the call */
+  args_hash: Fr;
+  /** Selector of the function to call */
+  function_selector: Fr;
+  /** Address of the contract to call */
+  target_address: Fr;
+  /** Whether the function is public or private */
+  is_public: boolean;
+  /** Whether the function can alter state */
+  is_static: boolean;
+};
+/* eslint-enable camelcase */
+
+/** Assembles an entrypoint payload */
+export abstract class EntrypointPayload {
+  protected constructor(
+    private functionCalls: EncodedFunctionCall[],
+    private _hashedArguments: HashedValues[],
+    private generatorIndex: number,
+    private _nonce: Fr,
+  ) {}
+
+  protected static async create(functionCalls: FunctionCall[]) {
+    const hashedArguments: HashedValues[] = [];
+    for (const call of functionCalls) {
+      hashedArguments.push(await HashedValues.fromValues(call.args));
+    }
+
+    /* eslint-disable camelcase */
+    const encodedFunctionCalls = functionCalls.map((call, index) => ({
+      args_hash: hashedArguments[index].hash,
+      function_selector: call.selector.toField(),
+      target_address: call.to.toField(),
+      is_public: call.type == FunctionType.PUBLIC,
+      is_static: call.isStatic,
+    }));
+    /* eslint-enable camelcase */
+
+    return {
+      encodedFunctionCalls,
+      hashedArguments,
+    };
+  }
+
+  /* eslint-disable camelcase */
+  /**
+   * The function calls to execute. This uses snake_case naming so that it is compatible with Noir encoding
+   * @internal
+   */
+  get function_calls() {
+    return this.functionCalls;
+  }
+  /* eslint-enable camelcase */
+
+  /**
+   * The nonce
+   * @internal
+   */
+  get nonce() {
+    return this._nonce;
+  }
+
+  /**
+   * The hashed arguments for the function calls
+   */
+  get hashedArguments() {
+    return this._hashedArguments;
+  }
+
+  /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */
+  abstract toFields(): Fr[];
+
+  /**
+   * Hashes the payload
+   * @returns The hash of the payload
+   */
+  hash() {
+    return poseidon2HashWithSeparator(this.toFields(), this.generatorIndex);
+  }
+
+  /** Serializes the function calls to an array of fields. */
+  protected functionCallsToFields() {
+    return this.functionCalls.flatMap(call => [
+      call.args_hash,
+      call.function_selector,
+      call.target_address,
+      new Fr(call.is_public),
+      new Fr(call.is_static),
+    ]);
+  }
+
+  /**
+   * Creates an execution payload for a dapp from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @returns The execution payload
+   */
+  static async fromFunctionCalls(functionCalls: FunctionCall[]) {
+    const { encodedFunctionCalls, hashedArguments } = await this.create(functionCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, 0, Fr.random());
+  }
+
+  /**
+   * Creates an execution payload for the app-portion of a transaction from a set of function calls
+   * @param functionCalls - The function calls to execute
+   * @param nonce - The nonce for the payload, used to emit a nullifier identifying the call
+   * @returns The execution payload
+   */
+  static async fromAppExecution(functionCalls: FunctionCall[] | Tuple<FunctionCall, 4>, nonce = Fr.random()) {
+    if (functionCalls.length > APP_MAX_CALLS) {
+      throw new Error(`Expected at most ${APP_MAX_CALLS} function calls, got ${functionCalls.length}`);
+    }
+    const paddedCalls = padArrayEnd(functionCalls, FunctionCall.empty(), APP_MAX_CALLS);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new AppEntrypointPayload(encodedFunctionCalls, hashedArguments, GeneratorIndex.SIGNATURE_PAYLOAD, nonce);
+  }
+
+  /**
+   * Creates an execution payload to pay the fee for a transaction
+   * @param sender - The address sending this payload
+   * @param feeOpts - The fee payment options
+   * @returns The execution payload
+   */
+  static async fromFeeOptions(sender: AztecAddress, feeOpts?: FeeOptions) {
+    const calls = (await feeOpts?.paymentMethod.getFunctionCalls(feeOpts?.gasSettings)) ?? [];
+    const feePayer = await feeOpts?.paymentMethod.getFeePayer(feeOpts?.gasSettings);
+    const isFeePayer = !!feePayer && feePayer.equals(sender);
+    const paddedCalls = padArrayEnd(calls, FunctionCall.empty(), FEE_MAX_CALLS);
+    const { encodedFunctionCalls, hashedArguments } = await this.create(paddedCalls);
+    return new FeeEntrypointPayload(
+      encodedFunctionCalls,
+      hashedArguments,
+      GeneratorIndex.FEE_PAYLOAD,
+      Fr.random(),
+      isFeePayer,
+    );
+  }
+}
+
+/** Entrypoint payload for app phase execution. */
+class AppEntrypointPayload extends EntrypointPayload {
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.nonce];
+  }
+}
+
+/** Entrypoint payload for fee payment to be run during setup phase. */
+class FeeEntrypointPayload extends EntrypointPayload {
+  #isFeePayer: boolean;
+
+  constructor(
+    functionCalls: EncodedFunctionCall[],
+    hashedArguments: HashedValues[],
+    generatorIndex: number,
+    nonce: Fr,
+    isFeePayer: boolean,
+  ) {
+    super(functionCalls, hashedArguments, generatorIndex, nonce);
+    this.#isFeePayer = isFeePayer;
+  }
+
+  override toFields(): Fr[] {
+    return [...this.functionCallsToFields(), this.nonce, new Fr(this.#isFeePayer)];
+  }
+
+  /* eslint-disable camelcase */
+  /** Whether the sender should be appointed as fee payer. */
+  get is_fee_payer() {
+    return this.#isFeePayer;
+  }
+  /* eslint-enable camelcase */
+}
+
+/**
+ * Computes a hash of a combined payload.
+ * @param appPayload - An app payload.
+ * @param feePayload - A fee payload.
+ * @returns A hash of a combined payload.
+ */
+export async function computeCombinedPayloadHash(
+  appPayload: AppEntrypointPayload,
+  feePayload: FeeEntrypointPayload,
+): Promise<Fr> {
+  return poseidon2HashWithSeparator(
+    [await appPayload.hash(), await feePayload.hash()],
+    GeneratorIndex.COMBINED_PAYLOAD,
+  );
+}

package/src/fee/fee_juice_payment_method.ts

@@ -0,0 +1,26 @@
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { FeePaymentMethod } from './fee_payment_method.js';
+
+// docs:start:fee_juice_method
+/**
+ * Pay fee directly in the Fee Juice.
+ */
+export class FeeJuicePaymentMethod implements FeePaymentMethod {
+  // docs:end:fee_juice_method
+  constructor(protected sender: AztecAddress) {}
+
+  getAsset() {
+    return Promise.resolve(ProtocolContractAddress.FeeJuice);
+  }
+
+  getFunctionCalls(): Promise<FunctionCall[]> {
+    return Promise.resolve([]);
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.sender);
+  }
+}

package/src/fee/fee_juice_payment_method_with_claim.ts

@@ -0,0 +1,49 @@
+import { Fr } from '@aztec/foundation/fields';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+
+import type { L2AmountClaim } from '../api/ethereum/portal_manager.js';
+import { getFeeJuice } from '../contract/protocol_contracts.js';
+import type { Wallet } from '../wallet/index.js';
+import { FeeJuicePaymentMethod } from './fee_juice_payment_method.js';
+
+/**
+ * Pay fee directly with Fee Juice claimed on the same tx.
+ */
+export class FeeJuicePaymentMethodWithClaim extends FeeJuicePaymentMethod {
+  constructor(
+    private senderWallet: Wallet,
+    private claim: Pick<L2AmountClaim, 'claimAmount' | 'claimSecret' | 'messageLeafIndex'>,
+  ) {
+    super(senderWallet.getAddress());
+  }
+
+  /**
+   * Creates a function call to pay the fee in Fee Juice.
+   * @returns A function call
+   */
+  override async getFunctionCalls(): Promise<FunctionCall[]> {
+    const canonicalFeeJuice = await getFeeJuice(this.senderWallet);
+    const selector = await FunctionSelector.fromNameAndParameters(
+      canonicalFeeJuice.artifact.functions.find(f => f.name === 'claim')!,
+    );
+
+    return Promise.resolve([
+      {
+        to: ProtocolContractAddress.FeeJuice,
+        name: 'claim',
+        selector,
+        isStatic: false,
+        args: [
+          this.senderWallet.getAddress().toField(),
+          new Fr(this.claim.claimAmount),
+          this.claim.claimSecret,
+          new Fr(this.claim.messageLeafIndex),
+        ],
+        returnTypes: [],
+        type: FunctionType.PRIVATE,
+      },
+    ]);
+  }
+}

package/src/fee/fee_payment_method.ts

@@ -0,0 +1,22 @@
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export interface FeePaymentMethod {
+  /** The asset used to pay the fee. */
+  getAsset(): Promise<AztecAddress>;
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * @param gasSettings - The gas limits and max fees.
+   * @returns The function call to pay the fee.
+   */
+  getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]>;
+  /**
+   * The expected fee payer for this tx.
+   * @param gasSettings - The gas limits and max fees.
+   */
+  getFeePayer(gasSettings: GasSettings): Promise<AztecAddress>;
+}

package/src/fee/private_fee_payment_method.ts

@@ -0,0 +1,118 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type FunctionCall, FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+
+import type { Wallet } from '../account/wallet.js';
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import { SignerlessWallet } from '../wallet/signerless_wallet.js';
+import type { FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export class PrivateFeePaymentMethod implements FeePaymentMethod {
+  private assetPromise: Promise<AztecAddress> | null = null;
+
+  constructor(
+    /**
+     * Address which will hold the fee payment.
+     */
+    private paymentContract: AztecAddress,
+
+    /**
+     * An auth witness provider to authorize fee payments
+     */
+    private wallet: Wallet,
+
+    /**
+     * If true, the max fee will be set to 1.
+     * TODO(#7694): Remove this param once the lacking feature in TXE is implemented.
+     */
+    private setMaxFeeToOne = false,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  getAsset(): Promise<AztecAddress> {
+    if (!this.assetPromise) {
+      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
+      const signerlessWallet = new SignerlessWallet(this.wallet);
+
+      const interaction = new ContractFunctionInteraction(
+        signerlessWallet,
+        this.paymentContract,
+        {
+          name: 'get_accepted_asset',
+          functionType: FunctionType.PRIVATE,
+          isInternal: false,
+          isStatic: false,
+          parameters: [],
+          returnTypes: [
+            {
+              kind: 'struct',
+              path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+              fields: [
+                {
+                  name: 'inner',
+                  type: {
+                    kind: 'field',
+                  },
+                },
+              ],
+            },
+          ],
+          errorTypes: {},
+          isInitializer: false,
+        },
+        [],
+      );
+
+      this.assetPromise = interaction.simulate();
+    }
+    return this.assetPromise!;
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * @param gasSettings - The gas settings.
+   * @returns The function call to pay the fee.
+   */
+  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+    // We assume 1:1 exchange rate between fee juice and token. But in reality you would need to convert feeLimit
+    // (maxFee) to be in token denomination.
+    const maxFee = this.setMaxFeeToOne ? Fr.ONE : gasSettings.getFeeLimit();
+    const nonce = Fr.random();
+
+    await this.wallet.createAuthWit({
+      caller: this.paymentContract,
+      action: {
+        name: 'transfer_to_public',
+        args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), maxFee, nonce],
+        selector: await FunctionSelector.fromSignature('transfer_to_public((Field),(Field),u128,Field)'),
+        type: FunctionType.PRIVATE,
+        isStatic: false,
+        to: await this.getAsset(),
+        returnTypes: [],
+      },
+    });
+
+    return [
+      {
+        name: 'fee_entrypoint_private',
+        to: this.paymentContract,
+        selector: await FunctionSelector.fromSignature('fee_entrypoint_private(u128,Field)'),
+        type: FunctionType.PRIVATE,
+        isStatic: false,
+        args: [maxFee, nonce],
+        returnTypes: [],
+      },
+    ];
+  }
+}

package/src/fee/public_fee_payment_method.ts

@@ -0,0 +1,114 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { AccountWallet } from '../wallet/account_wallet.js';
+import { SignerlessWallet } from '../wallet/signerless_wallet.js';
+import type { FeePaymentMethod } from './fee_payment_method.js';
+
+/**
+ * Holds information about how the fee for a transaction is to be paid.
+ */
+export class PublicFeePaymentMethod implements FeePaymentMethod {
+  private assetPromise: Promise<AztecAddress> | null = null;
+
+  constructor(
+    /**
+     * Address which will hold the fee payment.
+     */
+    protected paymentContract: AztecAddress,
+    /**
+     * An auth witness provider to authorize fee payments
+     */
+    protected wallet: AccountWallet,
+  ) {}
+
+  /**
+   * The asset used to pay the fee.
+   * @returns The asset used to pay the fee.
+   */
+  getAsset(): Promise<AztecAddress> {
+    if (!this.assetPromise) {
+      // We use signer-less wallet because this function could be triggered before the associated account is deployed.
+      const signerlessWallet = new SignerlessWallet(this.wallet);
+
+      const interaction = new ContractFunctionInteraction(
+        signerlessWallet,
+        this.paymentContract,
+        {
+          name: 'get_accepted_asset',
+          functionType: FunctionType.PRIVATE,
+          isInternal: false,
+          isStatic: false,
+          parameters: [],
+          returnTypes: [
+            {
+              kind: 'struct',
+              path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress',
+              fields: [
+                {
+                  name: 'inner',
+                  type: {
+                    kind: 'field',
+                  },
+                },
+              ],
+            },
+          ],
+          errorTypes: {},
+          isInitializer: false,
+        },
+        [],
+      );
+
+      this.assetPromise = interaction.simulate();
+    }
+    return this.assetPromise!;
+  }
+
+  getFeePayer(): Promise<AztecAddress> {
+    return Promise.resolve(this.paymentContract);
+  }
+
+  /**
+   * Creates a function call to pay the fee in the given asset.
+   * @param gasSettings - The gas settings.
+   * @returns The function call to pay the fee.
+   */
+  async getFunctionCalls(gasSettings: GasSettings): Promise<FunctionCall[]> {
+    const nonce = Fr.random();
+    const maxFee = gasSettings.getFeeLimit();
+
+    const setPublicAuthWitInteraction = await this.wallet.setPublicAuthWit(
+      {
+        caller: this.paymentContract,
+        action: {
+          name: 'transfer_in_public',
+          args: [this.wallet.getAddress().toField(), this.paymentContract.toField(), maxFee, nonce],
+          selector: await FunctionSelector.fromSignature('transfer_in_public((Field),(Field),u128,Field)'),
+          type: FunctionType.PUBLIC,
+          isStatic: false,
+          to: await this.getAsset(),
+          returnTypes: [],
+        },
+      },
+      true,
+    );
+
+    return [
+      await setPublicAuthWitInteraction.request(),
+      {
+        name: 'fee_entrypoint_public',
+        to: this.paymentContract,
+        selector: await FunctionSelector.fromSignature('fee_entrypoint_public(u128,Field)'),
+        type: FunctionType.PRIVATE,
+        isStatic: false,
+        args: [maxFee, nonce],
+        returnTypes: [],
+      },
+    ];
+  }
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+/**
+ * This is our public api.
+ * Do NOT "export * from ..." here.
+ * Everything here should be explicit, to ensure we can clearly see everything we're exposing to the world.
+ * If it's exposed, people will use it, and then we can't remove/change the api without breaking client code.
+ * At the time of writing we overexpose things that should only be internal.
+ *
+ * TODO: Review and narrow scope of public api.
+ * We should also consider exposing subsections of the api via package.json exports, like we do with foundation.
+ * This can allow consumers to import much smaller parts of the library to incur less overhead.
+ * It will also allow web bundlers do perform intelligent chunking of bundles etc.
+ * Some work as been done on this within the api folder, providing the alternative import style of e.g.:
+ * ```typescript
+ *   import { TxHash } from '@aztec.js/tx_hash'
+ *   import { type ContractArtifact, type FunctionArtifact, FunctionSelector } from '@aztec/aztec.js/abi';
+ *   import { AztecAddress } from '@aztec/aztec.js/addresses';
+ *   import { EthAddress } from '@aztec/aztec.js/eth_address';
+ * ```
+ *
+ * TODO: Ultimately reimplement this mega exporter by mega exporting a granular api (then deprecate it).
+ */
+
+export { ContractDeployer } from './deployment/index.js';
+
+export { NoteSelector } from '@aztec/stdlib/abi';
+
+export { createCompatibleClient, createPXEClient } from './rpc_clients/index.js';
+
+export { type DeployAccountOptions } from './account_manager/index.js';
+
+export { AccountWallet, AccountWalletWithSecretKey, SignerlessWallet } from './wallet/index.js';
+
+export { EthAddress } from '@aztec/foundation/eth-address';
+
+export { Fq, Fr, Point, GrumpkinScalar } from '@aztec/foundation/fields';
+
+export { SiblingPath } from '@aztec/foundation/trees';
+
+export { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+
+export {
+  type PartialAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
+  getContractClassFromArtifact,
+  getContractInstanceFromDeployParams,
+  type NodeInfo,
+} from '@aztec/stdlib/contract';
+export { MerkleTreeId, merkleTreeIds } from '@aztec/stdlib/trees';
+export { type PublicKey, PublicKeys } from '@aztec/stdlib/keys';
+export { computeSecretHash } from '@aztec/stdlib/hash';
+export {
+  computeAppNullifierSecretKey,
+  deriveKeys,
+  deriveMasterIncomingViewingSecretKey,
+  deriveMasterNullifierSecretKey,
+} from '@aztec/stdlib/keys';
+export { AuthWitness } from '@aztec/stdlib/auth-witness';
+export { getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+export { FunctionCall } from '@aztec/stdlib/abi';
+export {
+  Tx,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  TxStatus,
+  Capsule,
+  HashedValues,
+  GlobalVariables,
+} from '@aztec/stdlib/tx';
+export { Body, L2Block } from '@aztec/stdlib/block';
+export { L1NotePayload, LogId, type LogFilter, EncryptedLogPayload } from '@aztec/stdlib/logs';
+export { L1EventPayload, EventMetadata } from '@aztec/stdlib/event';
+export { L1ToL2Message, L2Actor, L1Actor } from '@aztec/stdlib/messaging';
+export { UniqueNote, ExtendedNote, Comparator, Note } from '@aztec/stdlib/note';
+export { type PXE, EventType } from '@aztec/stdlib/interfaces/client';
+
+export { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+// TODO: These kinds of things have no place on our public api.
+// External devs will almost certainly have their own methods of doing these things.
+// If we want to use them in our own "aztec.js consuming code", import them from foundation as needed.
+export { decodeFromAbi, encodeArguments, type AbiType } from '@aztec/stdlib/abi';
+export { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+export { sha256, Grumpkin, Schnorr } from '@aztec/foundation/crypto';
+export { makeFetch } from '@aztec/foundation/json-rpc/client';
+export { retry, retryUntil } from '@aztec/foundation/retry';
+export { to2Fields, toBigInt } from '@aztec/foundation/serialize';
+export { sleep } from '@aztec/foundation/sleep';
+export { elapsed } from '@aztec/foundation/timer';
+export { type FieldsOf } from '@aztec/foundation/types';
+export { fileURLToPath } from '@aztec/foundation/url';
+
+// Start of section that exports public api via granular api.
+// Here you *can* do `export *` as the granular api defacto exports things explicitly.
+// This entire index file will be deprecated at some point after we're satisfied.
+export * from './api/abi.js';
+export * from './api/account.js';
+export * from './api/addresses.js';
+export * from './api/cheat_codes.js';
+export * from './api/ethereum/index.js';
+export * from './api/fee.js';
+export * from './api/log.js';
+// Granular export, even if not in the api folder
+export * from './contract/index.js';
+export * from './utils/index.js';

package/src/rpc_clients/index.ts

@@ -0,0 +1,2 @@
+export * from './pxe_client.js';
+export * from './node/index.js';