@aztec-labs/aztec 6.0.0-nightly.20260829

package/src/local-network/local-network.ts

@@ -0,0 +1,254 @@
+#!/usr/bin/env -S node --no-warnings
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { createAztecNodeService } from '@aztec-labs/aztec-node';
+import { type AztecNodeConfig, getConfigEnvVars } from '@aztec-labs/aztec-node/config';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { createLogger } from '@aztec-labs/aztec.js/log';
+import { type BlobClientInterface, createBlobClient } from '@aztec-labs/blob-client/client';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec-labs/constants';
+import { waitForPublicClient } from '@aztec-labs/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { NULL_KEY } from '@aztec-labs/ethereum/constants';
+import { deployAztecL1Contracts } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import type { L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { DateProvider, TestDateProvider } from '@aztec-labs/foundation/timer';
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec-labs/stdlib/interfaces/server';
+import { TxStatus } from '@aztec-labs/stdlib/tx';
+import type { GenesisData } from '@aztec-labs/stdlib/world-state';
+import {
+  type TelemetryClient,
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+} from '@aztec-labs/telemetry-client';
+import { EmbeddedWallet } from '@aztec-labs/wallets/embedded';
+import { createFundedInitializerlessAccounts } from '@aztec-labs/wallets/testing';
+import { getGenesisValues } from '@aztec-labs/world-state/testing';
+import type { Hex } from 'viem';
+import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { createAccountLogs } from '../cli/util.js';
+import { DefaultMnemonic } from '../mnemonic.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
+import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
+import { getSponsoredFPCAddress } from './sponsored_fpc.js';
+
+const logger = createLogger('local-network');
+
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = { waitForStatus: TxStatus.CHECKPOINTED };
+
+/**
+ * Function to deploy our L1 contracts to the local network L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export async function deployContractsToL1(
+  aztecNodeConfig: AztecNodeConfig,
+  privateKey: Hex,
+  opts: {
+    genesisArchiveRoot?: Fr;
+    feeJuicePortalInitialBalance?: bigint;
+  } = {},
+): Promise<L1ContractAddresses> {
+  await waitForPublicClient(aztecNodeConfig);
+
+  const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+    ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+    ...aztecNodeConfig,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+    feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+    aztecTargetCommitteeSize: 0, // no committee in local network
+    slasherEnabled: false, // no slashing in local network
+    realVerifier: false,
+  });
+
+  Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
+  aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
+
+  return l1Contracts.l1ContractAddresses;
+}
+
+/** Local network settings. */
+export type LocalNetworkConfig = AztecNodeConfig & {
+  /** Mnemonic used to derive the L1 deployer private key.*/
+  l1Mnemonic: string;
+  /** Whether to deploy test accounts on local network start.*/
+  testAccounts: boolean;
+  /** Override the default per-address fee juice granted at genesis to funded addresses. */
+  initialAccountFeeJuice?: Fr;
+};
+
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional local network settings.
+ */
+export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {}, userLog: LogFn) {
+  // local network is meant for test envs. We should only need one l1RpcUrl
+  const l1RpcUrl = config.l1RpcUrls?.[0];
+  if (!l1RpcUrl) {
+    throw new Error('An L1 RPC URL is required');
+  }
+  if ((config.l1RpcUrls?.length || 0) > 1) {
+    logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
+  }
+
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
+  const envConfig = getConfigEnvVars();
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...envConfig,
+    ...config,
+    skipOrphanProposedBlockPruning: true,
+    // The local network builds node config from env without a DATA_DIRECTORY, so the validator's
+    // local signing protection runs against an ephemeral store. That is acceptable for this dev
+    // network; production validators must persist it and fail-fast when the data directory is unset.
+    allowEphemeralSigningProtection: config.allowEphemeralSigningProtection ?? true,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+    // The local network runs against anvil with no committee, so it defaults to the deterministic
+    // AutomineSequencer, which owns L1 time control (warps the dateProvider and L1 timestamps to slot
+    // boundaries as it builds), replacing the deleted AnvilTestWatcher. This remains true when p2p is
+    // enabled for local peer testing; local-network is not a mode for connecting to an existing network.
+    useAutomineSequencer: config.useAutomineSequencer ?? true,
+    // The AutomineSequencer owns epoch proving in the local network — it writes epoch out hashes to
+    // the L1 Outbox and advances the proven tip as checkpoints land, through the same serial queue as
+    // its builds — replacing the standalone EpochTestSettler that used to race the build loop.
+    automineEnableProveEpoch: config.automineEnableProveEpoch ?? true,
+    // Defaults for the local network / sandbox; callers (e.g. the CLI) may override. No real proving
+    // happens here — the AutomineSequencer synthetically settles epochs. Short epochs let it write out
+    // hashes quickly (so users can consume L2-to-L1 messages without a long wait), with a wider
+    // proof-submission window so the synthetic settler has headroom before the rollup would prune an
+    // unproven checkpoint.
+    realProofs: config.realProofs ?? false,
+    aztecEpochDuration: config.aztecEpochDuration ?? 4,
+    aztecProofSubmissionEpochs: config.aztecProofSubmissionEpochs ?? 2,
+  };
+  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+  if (
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
+  ) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
+  }
+  if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${Buffer.from(privKey!).toString('hex')}`]);
+  }
+  aztecNodeConfig.coinbase = EthAddress.fromString(
+    privateKeyToAddress(aztecNodeConfig.validatorPrivateKeys.getValue()[0]),
+  );
+
+  const initialAccounts = await (async () => {
+    if (config.testAccounts === true || config.testAccounts === undefined) {
+      if (aztecNodeConfig.p2pEnabled) {
+        userLog(`Not setting up test accounts when p2p is enabled`);
+      } else {
+        userLog(`Setting up test accounts`);
+        return await getInitialTestAccountsData();
+      }
+    }
+    return [];
+  })();
+
+  const bananaFPC = await getBananaFPCAddress(initialAccounts);
+  const sponsoredFPC = await getSponsoredFPCAddress();
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromStringUnsafe(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
+  const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(
+    fundedAddresses,
+    config.initialAccountFeeJuice,
+  );
+
+  const dateProvider = new TestDateProvider();
+
+  if (!aztecNodeConfig.p2pEnabled) {
+    await deployContractsToL1(aztecNodeConfig, aztecNodeConfig.validatorPrivateKeys.getValue()[0], {
+      genesisArchiveRoot,
+      feeJuicePortalInitialBalance: fundingNeeded,
+    });
+  }
+
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob client client inside the local network, no http connectivity
+  const blobClient = createBlobClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { genesis });
+
+  if (initialAccounts.length) {
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
+
+    userLog('Setting up funded test accounts...');
+    const accountManagers = await createFundedInitializerlessAccounts(wallet, initialAccounts);
+    const accLogs = await createAccountLogs(accountManagers, wallet);
+    userLog(accLogs.join(''));
+
+    userLog('Publishing standard AuthRegistry contract...');
+    await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+
+    await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
+
+    userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
+
+    // We no longer need the wallet once we've setup the accounts so we stop the underlying PXE job queue
+    await wallet.stop();
+  }
+
+  const stop = async () => {
+    await node.stop();
+  };
+
+  return { node, stop };
+}
+
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export async function createAztecNode(
+  config: Partial<AztecNodeConfig> = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
+  options: { genesis?: GenesisData } = {},
+) {
+  // TODO(#12272): will clean this up. This is criminal.
+  // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+  };
+  const node = await createAztecNodeService(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
+  return node;
+}

package/src/local-network/sponsored_fpc.ts

@@ -0,0 +1,26 @@
+import type { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import {
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec-labs/aztec.js/contracts';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import type { Wallet } from '@aztec-labs/aztec.js/wallet';
+import { SPONSORED_FPC_SALT } from '@aztec-labs/constants';
+import { SponsoredFPCContract } from '@aztec-labs/noir-contracts.js/SponsoredFPC';
+
+async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
+  return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+    salt: new Fr(SPONSORED_FPC_SALT),
+  });
+}
+
+export async function getSponsoredFPCAddress(): Promise<AztecAddress> {
+  return (await getSponsoredFPCInstance()).address;
+}
+
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<AztecAddress> {
+  const fpc = await getSponsoredFPCInstance();
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, SponsoredFPCContract.artifact);
+  return fpc.address;
+}

package/src/mnemonic.ts

@@ -0,0 +1 @@
+export const DefaultMnemonic = 'test test test test test test test test test test test junk';

package/src/splash.ts

@@ -0,0 +1,10 @@
+export const splash: string =
+  '\n' +
+  '               _\n' +
+  '    /\\        | |\n' +
+  '   /  \\    ___| |_ ___  ___ \n' +
+  '  / /\\ \\  |_  / __/ _ \\/ __|\n' +
+  ' / ____ \\  / /| ||  __/ (__ \n' +
+  '/_/___ \\_\\/___|\\__\\___|\\___|\n';
+
+export const github = 'https://github.com/AztecProtocol';

package/src/testing/cheat_codes.ts

@@ -0,0 +1,48 @@
+import { EthCheatCodes, RollupCheatCodes } from '@aztec-labs/ethereum/test';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { AztecNode, AztecNodeDebug } from '@aztec-labs/stdlib/interfaces/client';
+
+/**
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
+ */
+export class CheatCodes {
+  constructor(
+    /** Cheat codes for L1.*/
+    public eth: EthCheatCodes,
+    /** Cheat codes for the Aztec Rollup contract on L1. */
+    public rollup: RollupCheatCodes,
+  ) {}
+
+  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
+    const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
+    const rollupCheatCodes = new RollupCheatCodes(
+      ethCheatCodes,
+      await node.getNodeInfo().then(n => n.l1ContractAddresses),
+    );
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
+  }
+
+  /**
+   * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+   * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
+   */
+  warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastTo(Number(targetTimestamp));
+  }
+
+  /**
+   * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+   * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+   * queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param duration - The duration to advance time by (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
+   */
+  warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void> {
+    return node.warpL2TimeAtLeastBy(Number(duration));
+  }
+}

package/src/testing/epoch_test_settler.ts

@@ -0,0 +1,47 @@
+import { type EthCheatCodes, RollupCheatCodes } from '@aztec-labs/ethereum/test';
+import type { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { settleEpochOutbox } from '@aztec-labs/prover-client/test';
+import { EpochMonitor } from '@aztec-labs/prover-node';
+import type { EthAddress, L2BlockSource } from '@aztec-labs/stdlib/block';
+
+export class EpochTestSettler {
+  private rollupCheatCodes: RollupCheatCodes;
+  private epochMonitor?: EpochMonitor;
+
+  constructor(
+    cheatcodes: EthCheatCodes,
+    rollupAddress: EthAddress,
+    private l2BlockSource: L2BlockSource,
+    private log: Logger,
+    private options: { pollingIntervalMs: number; provingDelayMs?: number },
+  ) {
+    this.rollupCheatCodes = new RollupCheatCodes(cheatcodes, { rollupAddress });
+  }
+
+  async start() {
+    const { epochDuration } = await this.rollupCheatCodes.getConfig();
+    this.epochMonitor = new EpochMonitor(this.l2BlockSource, { epochDuration: Number(epochDuration) }, this.options);
+    this.epochMonitor.start(this);
+  }
+
+  async stop() {
+    await this.epochMonitor?.stop();
+  }
+
+  async handleEpochReadyToProve(epoch: EpochNumber): Promise<boolean> {
+    const lastCheckpoint = await settleEpochOutbox({
+      rollupCheatCodes: this.rollupCheatCodes,
+      l2BlockSource: this.l2BlockSource,
+      epoch,
+      log: this.log,
+    });
+    if (lastCheckpoint !== undefined) {
+      await this.rollupCheatCodes.markAsProven(lastCheckpoint);
+    } else {
+      this.log.warn(`No checkpoint found for epoch ${epoch}`);
+    }
+
+    return true;
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+export { EthCheatCodes, RollupCheatCodes } from '@aztec-labs/ethereum/test';
+export { CheatCodes } from './cheat_codes.js';
+export { EpochTestSettler } from './epoch_test_settler.js';
+export { setupLocalNetwork, TEST_FEE_PADDING, type LocalNetwork, type LocalNetworkOptions } from './local-network.js';
+export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';

package/src/testing/local-network.ts

@@ -0,0 +1,96 @@
+import type { AztecNodeService } from '@aztec-labs/aztec-node';
+import type { AztecNodeConfig } from '@aztec-labs/aztec-node/config';
+import type { Fr } from '@aztec-labs/aztec.js/fields';
+import { startAnvil } from '@aztec-labs/ethereum/test';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { foundry } from 'viem/chains';
+
+import { createLocalNetwork } from '../local-network/local-network.js';
+
+/** A running in-process local network: an inline Aztec node backed by its own anvil L1. */
+export interface LocalNetwork extends AsyncDisposable {
+  /** Fully-synced Aztec node, ready to serve client requests. */
+  node: AztecNodeService;
+  /** RPC URL of the spawned anvil instance. */
+  l1RpcUrl: string;
+  /** Chain id used on L1 (foundry's default 31337). */
+  l1ChainId: number;
+  /** Stops every process started by the fixture: node and anvil. Also invoked by `await using`. */
+  stop: () => Promise<void>;
+}
+
+/** Options for {@link setupLocalNetwork}. */
+export interface LocalNetworkOptions {
+  /**
+   * Addresses that should hold fee juice at genesis. Saves each of these the round-trip of bridging
+   * + claiming fee juice before they can pay for gas.
+   */
+  fundedAddresses?: AztecAddress[];
+  /** Override the default per-address genesis fee juice granted to {@link fundedAddresses}. */
+  initialAccountFeeJuice?: Fr;
+  /** Node config overrides, e.g. `realProofs`, `aztecEpochDuration`, `p2pEnabled`. */
+  config?: Partial<AztecNodeConfig>;
+}
+
+/**
+ * Spin up an in-process local network with the given addresses pre-funded.
+ *
+ * Each call spawns its own anvil on an OS-assigned random port and runs the Aztec node inline via
+ * the same {@link createLocalNetwork} codepath that backs `aztec start --local-network` (with the
+ * sandbox account/FPC/token setup skipped). Distinct ports let independent suites run in parallel.
+ * The caller must `await result.stop()` in its teardown (or hold the result with `await using`).
+ *
+ * Requires a Foundry toolchain (`anvil`/`forge`), installed via `aztec-up` or `foundryup`. Binaries
+ * are located in the standard install directories or on `PATH`; set `$ANVIL_BIN` / `$FORGE_BIN` to
+ * pin specific ones.
+ */
+export async function setupLocalNetwork(opts: LocalNetworkOptions = {}): Promise<LocalNetwork> {
+  // `--port 0` → anvil binds an ephemeral port that `startAnvil` reads back, so parallel suites
+  // never collide on a fixed port.
+  const { rpcUrl, stop: stopAnvil } = await startAnvil({ port: 0 });
+
+  try {
+    const { node, stop: stopNode } = await createLocalNetwork(
+      {
+        ...opts.config,
+        l1RpcUrls: [rpcUrl],
+        testAccounts: false,
+        prefundAddresses: (opts.fundedAddresses ?? []).map(a => a.toString()),
+        initialAccountFeeJuice: opts.initialAccountFeeJuice,
+      },
+      () => {},
+    );
+
+    // Stop the node before anvil (its teardown still talks to L1); the finally guarantees anvil is
+    // reaped even if node shutdown throws.
+    const stop = async () => {
+      try {
+        await stopNode();
+      } finally {
+        await stopAnvil();
+      }
+    };
+
+    return {
+      node,
+      l1RpcUrl: rpcUrl,
+      l1ChainId: foundry.id,
+      stop,
+      [Symbol.asyncDispose]: stop,
+    };
+  } catch (err) {
+    await stopAnvil();
+    throw err;
+  }
+}
+
+/**
+ * Min-fee padding multiplier for test wallets whose txs may mine well after their fee estimate.
+ * The automine sequencer builds one block per tx and advances L1 time in big jumps, and proposer
+ * pipelining evolves the fee-asset price across the build/publish gap (~20x observed in CI), so the
+ * network's congestion base fee can swing sharply between the wallet's fee estimate and the block
+ * the tx actually lands in. The default wallet padding isn't enough and trips
+ * `maxFeesPerGas.feePerL2Gas must be >= gasFees.feePerL2Gas`. Apply via
+ * `wallet.setMinFeePadding(TEST_FEE_PADDING)` on every test wallet that sends txs.
+ */
+export const TEST_FEE_PADDING = 30;

package/src/testing/token_allowed_setup.ts

@@ -0,0 +1,26 @@
+import { TokenContractArtifact } from '@aztec-labs/noir-contracts.js/Token';
+import { buildAllowedElement } from '@aztec-labs/p2p/msg_validators';
+import type { ContractArtifact } from '@aztec-labs/stdlib/abi';
+import { getContractClassFromArtifact } from '@aztec-labs/stdlib/contract';
+import type { AllowedElement } from '@aztec-labs/stdlib/interfaces/server';
+
+/**
+ * Returns the allowlist entries needed for FPC-based fee payments, keyed by the contract class of
+ * the `artifact` actually deployed as the fee token (defaults to canonical Token). The setup-phase
+ * validator matches these entries by class id, so a test deploying the codegen'd TestToken as its
+ * fee vehicle must pass `TestTokenContract.artifact` here -- otherwise the FPC fee calls are matched
+ * against the wrong class and rejected. Test-only: FPC fee payment with custom tokens won't work on
+ * mainnet alpha.
+ */
+export async function getTokenAllowedSetupFunctions(
+  artifact: ContractArtifact = TokenContractArtifact,
+): Promise<AllowedElement[]> {
+  const tokenClassId = (await getContractClassFromArtifact(artifact)).id;
+  const target = { classId: tokenClassId };
+  return Promise.all([
+    // needed for private transfers via FPC (transfer_to_public enqueues this)
+    buildAllowedElement(artifact, target, '_increase_public_balance', { onlySelf: true }),
+    // needed for public transfers via FPC (fee_entrypoint_public enqueues this)
+    buildAllowedElement(artifact, target, 'transfer_in_public'),
+  ]);
+}